diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index bb4c500283020..516de74378cbc 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -187,6 +187,9 @@ /x-pack/test/saved_object_tagging/ @elastic/kibana-core /packages/kbn-config-schema/ @elastic/kibana-core /packages/kbn-std/ @elastic/kibana-core +/packages/kbn-config/ @elastic/kibana-core +/packages/kbn-logging/ @elastic/kibana-core +/packages/kbn-legacy-logging/ @elastic/kibana-core /src/legacy/server/config/ @elastic/kibana-core /src/legacy/server/http/ @elastic/kibana-core /src/legacy/server/logging/ @elastic/kibana-core diff --git a/.i18nrc.json b/.i18nrc.json index 653c67b535bff..e921647b1c602 100644 --- a/.i18nrc.json +++ b/.i18nrc.json @@ -27,6 +27,7 @@ "src/plugins/management" ], "maps_legacy": "src/plugins/maps_legacy", + "monaco": "packages/kbn-monaco/src", "indexPatternManagement": "src/plugins/index_pattern_management", "advancedSettings": "src/plugins/advanced_settings", "kibana_legacy": "src/plugins/kibana_legacy", diff --git a/docs/apm/apm-alerts.asciidoc b/docs/apm/apm-alerts.asciidoc index 7bdfe80b42177..b4afc2788895c 100644 --- a/docs/apm/apm-alerts.asciidoc +++ b/docs/apm/apm-alerts.asciidoc @@ -6,7 +6,6 @@ Create an alert ++++ -beta::[] The APM app integrates with Kibana's {kibana-ref}/alerting-getting-started.html[alerting and actions] feature. It provides a set of built-in **actions** and APM specific threshold **alerts** for you to use diff --git a/docs/developer/plugin/migrating-legacy-plugins-examples.asciidoc b/docs/developer/plugin/migrating-legacy-plugins-examples.asciidoc index 8a0e487971b20..a033bbd26a1a7 100644 --- a/docs/developer/plugin/migrating-legacy-plugins-examples.asciidoc +++ b/docs/developer/plugin/migrating-legacy-plugins-examples.asciidoc @@ -1143,6 +1143,77 @@ router.get( ); ---- +==== Accessing the client from a collector's `fetch` method + +At the moment, the `fetch` method's context receives preconfigured +<> for Elasticsearch and SavedObjects. +To help in the transition, both, the legacy (`callCluster`) and new clients are provided, +but we strongly discourage using the deprecated legacy ones for any new implementation. + +[source,typescript] +---- +usageCollection.makeUsageCollector({ + type: 'my-collector', + isReady: async () => true, // Logic to confirm the `fetch` method is ready to be called + schema: {...}, + async fetch(context) { + const { callCluster, esClient, soClient } = context; + + // Before: + const result = callCluster('search', options) + + // After: + const { body: result } = esClient.search(options); + + return result; + } +}); +---- + +Regarding the `soClient`, it is encouraged to use it instead of the plugin's owned SavedObject's repository +as we used to do in the past. + +Before: + +[source,typescript] +---- +function getUsageCollector( + usageCollection: UsageCollectionSetup, + getSavedObjectsRepository: () => ISavedObjectsRepository | undefined +) { + usageCollection.makeUsageCollector({ + type: 'my-collector', + isReady: () => typeof getSavedObjectsRepository() !== 'undefined', + schema: {...}, + async fetch() { + const savedObjectsRepository = getSavedObjectsRepository(); + + const { attributes: result } = await savedObjectsRepository.get('my-so-type', 'my-so-id'); + + return result; + } + }); +} +---- + +After: + +[source,typescript] +---- +function getUsageCollector(usageCollection: UsageCollectionSetup) { + usageCollection.makeUsageCollector({ + type: 'my-collector', + isReady: () => true, + schema: {...}, + async fetch({ soClient }) { + const { attributes: result } = await soClient.get('my-so-type', 'my-so-id'); + + return result; + } + }); +} +---- + ==== Creating a custom client Note that the `plugins` option is no longer available on the new diff --git a/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.find.md b/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.find.md new file mode 100644 index 0000000000000..f642965c5da80 --- /dev/null +++ b/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.find.md @@ -0,0 +1,11 @@ + + +[Home](./index.md) > [kibana-plugin-plugins-data-public](./kibana-plugin-plugins-data-public.md) > [IndexPatternsService](./kibana-plugin-plugins-data-public.indexpatternsservice.md) > [find](./kibana-plugin-plugins-data-public.indexpatternsservice.find.md) + +## IndexPatternsService.find property + +Signature: + +```typescript +find: (search: string, size?: number) => Promise; +``` diff --git a/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.md b/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.md index 48019fe410b97..30ce1fa1de386 100644 --- a/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.md +++ b/docs/development/plugins/data/public/kibana-plugin-plugins-data-public.indexpatternsservice.md @@ -23,6 +23,7 @@ export declare class IndexPatternsService | [clearCache](./kibana-plugin-plugins-data-public.indexpatternsservice.clearcache.md) | | (id?: string | undefined) => void | Clear index pattern list cache | | [ensureDefaultIndexPattern](./kibana-plugin-plugins-data-public.indexpatternsservice.ensuredefaultindexpattern.md) | | EnsureDefaultIndexPattern | | | [fieldArrayToMap](./kibana-plugin-plugins-data-public.indexpatternsservice.fieldarraytomap.md) | | (fields: FieldSpec[], fieldAttrs?: FieldAttrs | undefined) => Record<string, FieldSpec> | Converts field array to map | +| [find](./kibana-plugin-plugins-data-public.indexpatternsservice.find.md) | | (search: string, size?: number) => Promise<IndexPattern[]> | | | [get](./kibana-plugin-plugins-data-public.indexpatternsservice.get.md) | | (id: string) => Promise<IndexPattern> | Get an index pattern by id. Cache optimized | | [getCache](./kibana-plugin-plugins-data-public.indexpatternsservice.getcache.md) | | () => Promise<SavedObject<IndexPatternSavedObjectAttrs>[] | null | undefined> | | | [getDefault](./kibana-plugin-plugins-data-public.indexpatternsservice.getdefault.md) | | () => Promise<IndexPattern | null> | Get default index pattern | diff --git a/docs/management/alerting/alert-details.asciidoc b/docs/management/alerting/alert-details.asciidoc index b108f79fe5bad..0510b90272f90 100644 --- a/docs/management/alerting/alert-details.asciidoc +++ b/docs/management/alerting/alert-details.asciidoc @@ -2,7 +2,6 @@ [[alert-details]] === Alert details -beta[] The *Alert details* page tells you about the state of the alert and provides granular control over the actions it is taking. diff --git a/docs/management/alerting/alert-management.asciidoc b/docs/management/alerting/alert-management.asciidoc index f348812550978..b4a5c3bc1931f 100644 --- a/docs/management/alerting/alert-management.asciidoc +++ b/docs/management/alerting/alert-management.asciidoc @@ -2,7 +2,6 @@ [[alert-management]] === Managing Alerts -beta[] The *Alerts* tab provides a cross-app view of alerting. Different {kib} apps like <>, <>, <>, and <> can offer their own alerts, and the *Alerts* tab provides a central place to: diff --git a/docs/management/alerting/alerts-and-actions-intro.asciidoc b/docs/management/alerting/alerts-and-actions-intro.asciidoc index 35a2452e99951..2352cb99bf543 100644 --- a/docs/management/alerting/alerts-and-actions-intro.asciidoc +++ b/docs/management/alerting/alerts-and-actions-intro.asciidoc @@ -2,7 +2,6 @@ [[managing-alerts-and-actions]] == Alerts and Actions -beta[] The *Alerts and Actions* UI lets you <> in a space, and provides tools to <> so that alerts can trigger actions like notification, indexing, and ticketing. diff --git a/docs/redirects.asciidoc b/docs/redirects.asciidoc index ccad3670d3d27..7c81b8f9bbd0d 100644 --- a/docs/redirects.asciidoc +++ b/docs/redirects.asciidoc @@ -153,13 +153,11 @@ This content has moved. See {ref}/index-mgmt.html[Index management]. This content has moved. See <>. - [role="exclude",id="document-context"] == View a document in context This content has moved. See <>. - [role="exclude",id="document-data"] == View document data @@ -169,3 +167,29 @@ This content has moved. See <>. == View field data statistics This content has moved. See <>. + +[role="exclude",id="known-plugins"] +== Known plugins + +This content has moved. See <>. + +[role="exclude",id="url-drilldown"] +== URL drilldown + +[float] +[[trigger-picker]] +=== Picking a trigger for a URL drilldown + +This page has moved. Refer to <>. + +[float] +[[templating]] +=== URL templating + +This page has moved. Refer to <>. + +[float] +[[variables]] +=== Variables + +This page has moved. Refer to <>. diff --git a/docs/user/alerting/alerting-getting-started.asciidoc b/docs/user/alerting/alerting-getting-started.asciidoc index 53aef4aaa062e..4eeecad079348 100644 --- a/docs/user/alerting/alerting-getting-started.asciidoc +++ b/docs/user/alerting/alerting-getting-started.asciidoc @@ -2,7 +2,6 @@ [[alerting-getting-started]] = Alerting and Actions -beta[] -- diff --git a/docs/user/dashboard/drilldowns.asciidoc b/docs/user/dashboard/drilldowns.asciidoc index 1b9896d7dea56..ff2c321f667c8 100644 --- a/docs/user/dashboard/drilldowns.asciidoc +++ b/docs/user/dashboard/drilldowns.asciidoc @@ -21,7 +21,7 @@ refer https://www.elastic.co/subscriptions[the subscription page]. ============================================== [float] -[[dashboard-drilldown]] +[[dashboard-drilldowns]] ==== Dashboard drilldowns Dashboard drilldowns enable you to open a dashboard from another dashboard, @@ -33,7 +33,7 @@ you can create a drilldown that navigates from the overall status dashboard to a that shows a single data center or server. [float] -[[url-drilldown]] +[[url-drilldowns]] ==== URL drilldowns beta[] URL drilldowns enable you to navigate from a dashboard to internal or external URLs. @@ -41,8 +41,8 @@ Destination URLs can be dynamic, depending on the dashboard context or user inte For example, if you have a dashboard that shows data from a Github repository, you can create a URL drilldown that opens Github from the dashboard. -Some panels support multiple interactions, also known as triggers. -The <> you use to create a <> depends on the trigger you choose. URL drilldowns support these types of triggers: +Some panels support multiple interactions, also known as triggers. +The <> you use to create a <> depends on the trigger you choose. URL drilldowns support these types of triggers: * *Single click* — A single data point in the visualization. diff --git a/docs/user/dashboard/url-drilldown.asciidoc b/docs/user/dashboard/url-drilldown.asciidoc index cf92016e23f19..617fae938f8f5 100644 --- a/docs/user/dashboard/url-drilldown.asciidoc +++ b/docs/user/dashboard/url-drilldown.asciidoc @@ -1,4 +1,4 @@ -[[url_templating]] +[[url_templating-language]] === URL templating beta[] @@ -137,7 +137,7 @@ Example: [float] -[[variables]] +[[url-template-variables]] ==== URL template variables The URL drilldown template has three sources for variables: diff --git a/docs/user/plugins.asciidoc b/docs/user/plugins.asciidoc index fa9e7d0c513b5..0ef5d1a237510 100644 --- a/docs/user/plugins.asciidoc +++ b/docs/user/plugins.asciidoc @@ -14,7 +14,7 @@ Plugin developers must release a new version of their plugin for each new {kib} ============================================== [float] -[[known-plugins]] +[[known-kibana-plugins]] == Known plugins The known plugins were tested for {kib} *5.x*, so we are unable to guarantee compatibility with your version of {kib}. The {kib} installer rejects any plugins that haven't been published for your specific version of {kib}. diff --git a/docs/user/whats-new.asciidoc b/docs/user/whats-new.asciidoc index 9c163180a4341..587f4588bb442 100644 --- a/docs/user/whats-new.asciidoc +++ b/docs/user/whats-new.asciidoc @@ -11,4 +11,4 @@ coming[8.0.0] // tag::notable-highlights[] -// end::notable-highlights[] \ No newline at end of file +// end::notable-highlights[] diff --git a/packages/kbn-legacy-logging/src/setup_logging.ts b/packages/kbn-legacy-logging/src/setup_logging.ts index 103e81249a136..3b8b4b167c63d 100644 --- a/packages/kbn-legacy-logging/src/setup_logging.ts +++ b/packages/kbn-legacy-logging/src/setup_logging.ts @@ -34,7 +34,7 @@ export async function setupLogging( // thrown every time we start the server. // In order to keep using the legacy logger until we remove it I'm just adding // a new hard limit here. - process.stdout.setMaxListeners(25); + process.stdout.setMaxListeners(40); return await server.register({ plugin: good, diff --git a/packages/kbn-monaco/scripts/constants.js b/packages/kbn-monaco/scripts/constants.js new file mode 100644 index 0000000000000..9008b2bceeb3c --- /dev/null +++ b/packages/kbn-monaco/scripts/constants.js @@ -0,0 +1,52 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +module.exports = { + licenseHeader: `/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ +`, + supportedContexts: [ + 'boolean_script_field_script_field', + 'date_script_field', + 'double_script_field_script_field', + 'filter', + 'ip_script_field_script_field', + 'long_script_field_script_field', + 'painless_test', + 'processor_conditional', + 'score', + 'string_script_field_script_field', + ], +}; diff --git a/packages/kbn-monaco/scripts/generate_autocomplete.js b/packages/kbn-monaco/scripts/generate_autocomplete.js new file mode 100644 index 0000000000000..f39035cd2218f --- /dev/null +++ b/packages/kbn-monaco/scripts/generate_autocomplete.js @@ -0,0 +1,102 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +const { join } = require('path'); +const { readdirSync, readFileSync, writeFileSync } = require('fs'); +const minimist = require('minimist'); +const semver = require('semver'); +const ora = require('ora'); +const del = require('del'); + +const { + cloneAndCheckout, + createAutocompleteDefinitions, + createAutocompleteExports, +} = require('./utils'); +const { supportedContexts } = require('./constants'); + +start( + minimist(process.argv.slice(2), { + string: ['tag', 'branch'], + }) +); + +function start(opts) { + const log = ora('Loading Elasticsearch repository').start(); + + if (opts.branch == null && semver.valid(opts.tag) === null) { + log.fail(`Missing or invalid tag: ${opts.tag}`); + return; + } + + const autocompleteOutputFolder = join( + __dirname, + '..', + 'src', + 'painless', + 'autocomplete_definitions' + ); + + log.text = 'Cleaning autocomplete definitions folder'; + del.sync([`${autocompleteOutputFolder}/**`]); + + cloneAndCheckout( + { log, tag: opts.tag, branch: opts.branch }, + (err, { esPainlessContextFolder }) => { + if (err) { + log.fail(err.message); + return; + } + + const painlessContextFolderContents = readdirSync(esPainlessContextFolder); + + // Generate autocomplete definitions + painlessContextFolderContents + .filter((file) => { + // Expected filename format: whitelist-.json + const contextName = file.split('.')[0].split('whitelist-').pop(); + return supportedContexts.includes(contextName); + }) + .forEach((file) => { + try { + const { name, classes: painlessClasses } = JSON.parse( + readFileSync(join(esPainlessContextFolder, file), 'utf8') + ); + const filePath = join(autocompleteOutputFolder, `${name}.json`); + const code = JSON.stringify( + { suggestions: createAutocompleteDefinitions(painlessClasses) }, + null, + 2 + ); + writeFileSync(filePath, code, { encoding: 'utf8' }); + } catch (err) { + log.fail(err.message); + } + }); + + // Create index.ts file for autocomplete definitions + const indexFilePath = join(autocompleteOutputFolder, 'index.ts'); + const indexCode = createAutocompleteExports(); + + writeFileSync(indexFilePath, indexCode, { encoding: 'utf8' }); + + log.succeed('Painless autocomplete definitions generated successfully'); + } + ); +} diff --git a/packages/kbn-monaco/scripts/utils/clone_es.js b/packages/kbn-monaco/scripts/utils/clone_es.js new file mode 100644 index 0000000000000..511cfd89fbf54 --- /dev/null +++ b/packages/kbn-monaco/scripts/utils/clone_es.js @@ -0,0 +1,149 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +const { accessSync, mkdirSync } = require('fs'); +const { join } = require('path'); +const simpleGit = require('simple-git'); + +// Note: The generated whitelists have not yet been merged to master +// so this script may fail until code in this branch has been merged: +// https://github.com/stu-elastic/elasticsearch/tree/scripting/whitelists +const esRepo = 'https://github.com/elastic/elasticsearch.git'; + +const esFolder = join(__dirname, '..', '..', 'elasticsearch'); +const esPainlessContextFolder = join( + esFolder, + 'modules', + 'lang-painless', + 'src', + 'main', + 'generated' +); + +/** + * Checks if the given path exists + * @param {string} path + * @returns {boolean} true if exists, false if not + */ +const pathExist = (path) => { + try { + accessSync(path); + return true; + } catch (err) { + return false; + } +}; + +/** + * Creates the given folder + * @param {string} name + * @returns {boolean} true on success, false on failure + */ +const createFolder = (name) => { + try { + mkdirSync(name); + return true; + } catch (err) { + return false; + } +}; + +/** + * Sets the Elasticsearch repository to the given branch or tag. + * If the repository is not present in `esFolder` it will + * clone the repository and the checkout the branch or tag. + * If the repository is already present but it cannot checkout to + * the given tag, it will perform a pull and then try again. + * + * This code was largely borrowed from the ES JS client: + * https://github.com/elastic/elasticsearch-js/blob/master/scripts/utils/clone-es.js + * + * @param {object} options + * @param {function} callback + */ +const cloneAndCheckout = (opts, callback) => { + const { log, tag, branch } = opts; + + let fresh = false; + let retry = 0; + + if (!pathExist(esFolder)) { + if (!createFolder(esFolder)) { + log.fail('Failed to create ES folder'); + return; + } + fresh = true; + } + + const git = simpleGit(esFolder); + + const pull = (cb) => { + log.text = 'Pulling Elasticsearch repository'; + + git.pull((err) => { + if (err) { + callback(err, { esPainlessContextFolder }); + return; + } + cb(); + }); + }; + + const clone = (cb) => { + log.text = 'Cloning Elasticsearch repository'; + + git.clone(esRepo, esFolder, (err) => { + if (err) { + callback(err, { esPainlessContextFolder }); + return; + } + cb(); + }); + }; + + const checkout = (alsoPull = false) => { + if (branch) { + log.text = `Checking out branch '${branch}'`; + } else { + log.text = `Checking out tag '${tag}'`; + } + + git.checkout(branch || tag, (err) => { + if (err) { + if (retry++ > 0) { + callback(new Error(`Cannot checkout '${branch || tag}'`), { esPainlessContextFolder }); + return; + } + return pull(checkout); + } + if (alsoPull) { + return pull(checkout); + } + callback(null, { esPainlessContextFolder }); + }); + }; + + if (fresh) { + clone(checkout); + } else { + checkout(Boolean(opts.branch)); + } +}; + +module.exports = cloneAndCheckout; diff --git a/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.js b/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.js new file mode 100644 index 0000000000000..93a1462367ac9 --- /dev/null +++ b/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.js @@ -0,0 +1,319 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +const reservedWords = ['valueOf', 'toString']; + +// Making an assumption that a method will not have >5 parameters +const parameterIndexToLetterMap = { + 0: 'a', + 1: 'b', + 2: 'c', + 3: 'd', + 4: 'e', + 5: 'f', +}; + +/** + * The suggestion name is sometimes prefixed by the Java package + * and needs to be removed for autocompletion. + * + * Some suggestions may also contain a "$" character, which indicates it is + * an inner class in Java. For Painless, the "$" needs to be converted to "." + * @param {string} name + * @returns {string} + */ +const getDisplayName = (name, imported) => { + let displayName = name; + + // If imported === true, we assume it is a Java class and need the short name + if (imported) { + displayName = name.split('.').pop() || name; + } + + return displayName.replace('$', '.'); +}; + +/** + * Filters the context data by primitives and returns an array of primitive names + * The current data structure from ES does not indicate if a field is + * a primitive or class, so we infer this by checking + * that no methods or fields are defined + * @param {string} contextData + * @returns {Array} + */ +const getPrimitives = (contextData) => { + return contextData + .filter( + ({ + static_fields: staticFields, + fields, + static_methods: staticMethods, + methods, + constructors, + }) => { + if ( + staticMethods.length === 0 && + methods.length === 0 && + staticFields.length === 0 && + fields.length === 0 && + constructors.length === 0 + ) { + return true; + } + } + ) + .map((type) => type.name); +}; + +/** + * Given the method name, array of parameters, and return value, + * we create a description of the method that will be + * used to display the help tooltip for the autocomplete suggestion + * + * Example of final format: pow(double a, double b): double + * + * Some methods support different parameter types and return values, so this is also supported + * and represented by the "|" character + * + * Example: Long.parseLong(String a, int b | String a): long + * + * @param {string} methodName + * @param {Array>} parameters + * @param {string} returnValue + * @returns {string} + */ +const getMethodDescription = (methodName, parameters, returnValues) => { + const parametersDescription = parameters.reduce((paramsDescription, paramsArray, index) => { + const isNotLastParameterSet = parameters.length - 1 !== index; + + const parameterSetDescription = paramsArray.reduce( + (description, parameterType, paramsArrayIndex) => { + const newParameterDescription = `${parameterType} ${parameterIndexToLetterMap[paramsArrayIndex]}`; + const isLastParameter = paramsArray.length - 1 === paramsArrayIndex; + + description = `${description}${newParameterDescription}${isLastParameter ? '' : ', '}`; + + return isNotLastParameterSet && isLastParameter ? `${description} | ` : description; + }, + '' + ); + + paramsDescription = `${paramsDescription}${parameterSetDescription}`; + + return paramsDescription; + }, ''); + + const uniqueReturnValues = [...new Set(returnValues)].join(' | '); + + return `${methodName}(${parametersDescription}): ${uniqueReturnValues}`; +}; + +/** + * If a method supports multiple types of parameters, it is listed + * twice in the dataset. This method filters out the duplicates and + * adds all possible parameters to a method + * + * @param {Array} methods + * @returns {Array} + */ +const removeDuplicateMethods = (methods) => { + if (methods.length === 0) { + return []; + } + + const filteredMethods = methods.filter( + (method, index, methodsArray) => index === methodsArray.findIndex((m) => m.name === method.name) + ); + + const paramsToMethodMap = methods.reduce((acc, currentVal) => { + const { name, parameters, return: returnValue } = currentVal; + const hasParameters = parameters.length > 0; + + let methodName = name; + + if (reservedWords.includes(name)) { + methodName = `${name}MethodName`; + } + + if (acc[methodName] === undefined) { + acc[methodName] = { + parameters: hasParameters ? [parameters] : [], + returnValues: returnValue ? [returnValue] : [], + }; + } else { + const hasIncomingParameters = acc[methodName].parameters.length > 0; + const hasIncomingReturnValue = acc[methodName].returnValues.length > 0; + + if (hasParameters && hasIncomingParameters) { + acc[methodName].parameters = [parameters, ...acc[methodName].parameters]; + } else { + acc[methodName].parameters = [parameters]; + } + + if (returnValue && hasIncomingReturnValue) { + acc[methodName].returnValues = [returnValue, ...acc[methodName].returnValues]; + } else { + acc[methodName].returnValues = [returnValue]; + } + } + + return acc; + }, {}); + + return filteredMethods.map((method) => { + const methodName = reservedWords.includes(method.name) + ? `${method.name}MethodName` + : method.name; + + return { + name: method.name, + type: method.type, + parameters: paramsToMethodMap[methodName].parameters || [], + returnValues: paramsToMethodMap[methodName].returnValues || [], + }; + }); +}; + +/** + * Given a class, we return its fields and methods + * + * @param {object} painlessClass + * @returns {Array} + */ +const getPainlessClassToAutocomplete = (painlessClass) => { + const { staticFields, fields, staticMethods, methods } = painlessClass; + + const staticFieldsAutocomplete = staticFields.map(({ name, type }) => { + return { + label: name, + kind: 'property', + documentation: `${name}: ${type}`, + insertText: name, + }; + }); + + const fieldsAutocomplete = fields.map(({ name, type }) => { + return { + label: name, + kind: 'property', + documentation: `${name}: ${type}`, + insertText: name, + }; + }); + + const staticMethodsAutocomplete = removeDuplicateMethods(staticMethods).map( + ({ name, parameters, returnValues }) => { + return { + label: name, + kind: 'method', + documentation: getMethodDescription(name, parameters, returnValues), + insertText: name, + }; + } + ); + + const methodsAutocomplete = removeDuplicateMethods(methods).map( + ({ name, parameters, returnValues }) => { + return { + label: name, + kind: 'method', + documentation: getMethodDescription(name, parameters, returnValues), + insertText: name, + }; + } + ); + + return [ + ...staticFieldsAutocomplete, + ...staticMethodsAutocomplete, + ...methodsAutocomplete, + ...fieldsAutocomplete, + ]; +}; + +const getPainlessConstructorToAutocomplete = (constructors, imported) => { + if (constructors.length) { + // There are sometimes two constructor definitions if a parameter is accepted + // We only care about getting the constructor name for now, so we can access the first one in the array + const { declaring } = constructors[0]; + // The constructor name is sometimes prefixed by the Java package and needs to be removed + const constructorName = getDisplayName(declaring, imported); + + return { + label: constructorName, + kind: 'constructor', + documentation: `Constructor: ${constructorName}`, + insertText: constructorName, + }; + } + + return undefined; +}; + +/** + * Given an array of classes from an ES context definition, + * reformat the data in a way that can be more easily consumed by Monaco + * + * @param {Array} painlessClasses + * @returns {Array} + */ +const createAutocompleteDefinitions = (painlessClasses) => { + const suggestions = painlessClasses.map( + ({ + name, + static_fields: staticFields, + fields, + static_methods: staticMethods, + methods, + constructors, + imported, + }) => { + // The name is often prefixed by the Java package (e.g., Java.lang.Math) and needs to be removed + const displayName = getDisplayName(name, imported); + const isType = getPrimitives(painlessClasses).includes(name); + + const properties = getPainlessClassToAutocomplete({ + staticFields, + fields, + staticMethods, + methods, + }); + + const constructorDefinition = getPainlessConstructorToAutocomplete(constructors, imported); + + return { + label: displayName, + kind: isType ? 'type' : 'class', + documentation: isType ? `Primitive: ${displayName}` : `Class: ${displayName}`, + insertText: displayName, + properties: properties.length ? properties : undefined, + constructorDefinition, + }; + } + ); + + return suggestions; +}; + +module.exports = { + getMethodDescription, + getPrimitives, + getPainlessClassToAutocomplete, + createAutocompleteDefinitions, +}; diff --git a/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.test.js b/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.test.js new file mode 100644 index 0000000000000..82ace6a38e465 --- /dev/null +++ b/packages/kbn-monaco/scripts/utils/create_autocomplete_definitions.test.js @@ -0,0 +1,374 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ +const { + getPrimitives, + getMethodDescription, + getPainlessClassToAutocomplete, + createAutocompleteDefinitions, +} = require('./create_autocomplete_definitions'); + +// Snippet of sample data returned from GET _scripts/painless/_context?context= +const testContext = [ + { + name: 'boolean', + imported: true, + constructors: [], + static_methods: [], + methods: [], + static_fields: [], + fields: [], + }, + { + name: 'int', + imported: true, + constructors: [], + static_methods: [], + methods: [], + static_fields: [], + fields: [], + }, + { + name: 'java.lang.Long', + imported: true, + constructors: [], + static_methods: [ + { + declaring: 'java.lang.Long', + name: 'parseLong', + return: 'long', + parameters: ['java.lang.String'], + }, + { + declaring: 'java.lang.Long', + name: 'parseLong', + return: 'long', + parameters: ['java.lang.String', 'int'], + }, + ], + methods: [], + static_fields: [], + fields: [], + }, + { + name: 'java.lang.Math', + imported: true, + constructors: [], + static_methods: [ + { + declaring: 'java.lang.Math', + name: 'pow', + return: 'double', + parameters: ['double', 'double'], + }, + { + declaring: 'java.lang.Math', + name: 'random', + return: 'double', + parameters: [], + }, + ], + methods: [ + { + declaring: 'java.lang.Object', + name: 'toString', + return: 'java.lang.String', + parameters: [], + }, + ], + static_fields: [ + { + declaring: 'java.lang.Math', + name: 'PI', + type: 'double', + }, + ], + fields: [], + }, +]; + +describe('Autocomplete utils', () => { + describe('getPrimitives()', () => { + test('returns an array of primitives', () => { + expect(getPrimitives(testContext)).toEqual(['boolean', 'int']); + }); + }); + + describe('getMethodDescription()', () => { + test('returns a string describing the method', () => { + expect(getMethodDescription('pow', [['double', 'double']], ['double'])).toEqual( + 'pow(double a, double b): double' + ); + }); + test('represents each parameter as an alphabetical character', () => { + expect( + getMethodDescription( + 'myMethod', + [['string', 'string', 'string', 'string', 'string']], + ['string'] + ) + ).toEqual('myMethod(string a, string b, string c, string d, string e): string'); + }); + }); + + describe('getPainlessClassToAutocomplete()', () => { + test('returns the fields and methods associated with a class', () => { + const mathClass = testContext[3]; + + const { + static_fields: staticFields, + fields, + static_methods: staticMethods, + methods, + } = mathClass; + + expect( + getPainlessClassToAutocomplete({ + staticFields, + fields, + staticMethods, + methods, + }) + ).toEqual([ + { + documentation: 'PI: double', + insertText: 'PI', + kind: 'property', + label: 'PI', + }, + { + documentation: 'pow(double a, double b): double', + insertText: 'pow', + kind: 'method', + label: 'pow', + }, + { + documentation: 'random(): double', + insertText: 'random', + kind: 'method', + label: 'random', + }, + { + documentation: 'toString(): java.lang.String', + insertText: 'toString', + kind: 'method', + label: 'toString', + }, + ]); + }); + + test('removes duplicate methods', () => { + const longClass = testContext[2]; + + const { + static_fields: staticFields, + fields, + static_methods: staticMethods, + methods, + } = longClass; + + expect( + getPainlessClassToAutocomplete({ + staticFields, + fields, + staticMethods, + methods, + }) + ).toEqual([ + { + label: 'parseLong', + kind: 'method', + documentation: 'parseLong(java.lang.String a, int b | java.lang.String a): long', + insertText: 'parseLong', + }, + ]); + }); + + test('returns all possible return values in description', () => { + const charClass = { + name: 'java.lang.Character', + imported: true, + constructors: [], + static_methods: [ + { + declaring: 'java.lang.Character', + name: 'toChars', + return: '[C', + parameters: ['int'], + }, + { + declaring: 'java.lang.Character', + name: 'toChars', + return: 'int', + parameters: ['int', '[C', 'int'], + }, + ], + fields: [], + methods: [], + static_fields: [], + }; + + const { + static_fields: staticFields, + fields, + static_methods: staticMethods, + methods, + } = charClass; + + expect( + getPainlessClassToAutocomplete({ + staticFields, + fields, + staticMethods, + methods, + }) + ).toEqual([ + { + label: 'toChars', + kind: 'method', + documentation: 'toChars(int a, [C b, int c | int a): int | [C', + insertText: 'toChars', + }, + ]); + }); + }); + + describe('createAutocompleteDefinitions()', () => { + test('returns formatted autocomplete definitions', () => { + expect(createAutocompleteDefinitions(testContext)).toEqual([ + { + properties: undefined, + constructorDefinition: undefined, + documentation: 'Primitive: boolean', + insertText: 'boolean', + kind: 'type', + label: 'boolean', + }, + { + properties: undefined, + constructorDefinition: undefined, + documentation: 'Primitive: int', + insertText: 'int', + kind: 'type', + label: 'int', + }, + { + constructorDefinition: undefined, + documentation: 'Class: Long', + insertText: 'Long', + kind: 'class', + label: 'Long', + properties: [ + { + documentation: 'parseLong(java.lang.String a, int b | java.lang.String a): long', + insertText: 'parseLong', + kind: 'method', + label: 'parseLong', + }, + ], + }, + { + properties: [ + { + documentation: 'PI: double', + insertText: 'PI', + kind: 'property', + label: 'PI', + }, + { + documentation: 'pow(double a, double b): double', + insertText: 'pow', + kind: 'method', + label: 'pow', + }, + { + documentation: 'random(): double', + insertText: 'random', + kind: 'method', + label: 'random', + }, + { + documentation: 'toString(): java.lang.String', + insertText: 'toString', + kind: 'method', + label: 'toString', + }, + ], + constructorDefinition: undefined, + documentation: 'Class: Math', + insertText: 'Math', + kind: 'class', + label: 'Math', + }, + ]); + }); + + test('returns a constructor definition', () => { + const contextWithConstructors = [ + { + name: 'java.lang.ArithmeticException', + imported: true, + constructors: [ + { + declaring: 'java.lang.ArithmeticException', + parameters: [], + }, + { + declaring: 'java.lang.ArithmeticException', + parameters: ['java.lang.String'], + }, + ], + static_methods: [], + methods: [ + { + declaring: 'java.lang.Object', + name: 'equals', + return: 'boolean', + parameters: ['java.lang.Object'], + }, + ], + static_fields: [], + fields: [], + }, + ]; + + expect(createAutocompleteDefinitions(contextWithConstructors)).toEqual([ + { + constructorDefinition: { + documentation: 'Constructor: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'constructor', + label: 'ArithmeticException', + }, + documentation: 'Class: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'class', + label: 'ArithmeticException', + properties: [ + { + documentation: 'equals(java.lang.Object a): boolean', + insertText: 'equals', + kind: 'method', + label: 'equals', + }, + ], + }, + ]); + }); + }); +}); diff --git a/packages/kbn-monaco/scripts/utils/create_autocomplete_exports.js b/packages/kbn-monaco/scripts/utils/create_autocomplete_exports.js new file mode 100644 index 0000000000000..815fe334ad080 --- /dev/null +++ b/packages/kbn-monaco/scripts/utils/create_autocomplete_exports.js @@ -0,0 +1,49 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +const { licenseHeader, supportedContexts } = require('../constants'); + +const toCamelcase = (string) => { + return string.replace(/([_][a-z])/gi, (match) => { + return match.toUpperCase().replace('_', ''); + }); +}; + +const createAutocompleteExports = () => { + const imports = supportedContexts.reduce((importList, context) => { + const importStatement = ` +import * as ${toCamelcase(context)}Context from './${context}.json';`; + importList = `${importStatement}${importList}`; + return importList; + }, ''); + + const exports = supportedContexts.reduce((exportList, context) => { + const exportStatement = ` +export { ${toCamelcase(context)}Context };`; + exportList = `${exportStatement}${exportList}`; + return exportList; + }, ''); + + const doNotEditComment = `// DO NOT EDIT: THIS FILE CONTAINS GENERATED CODE. REFER TO THE PAINLESS README FOR MORE INFORMATION.`; + + return `${licenseHeader}${doNotEditComment}${imports}${exports} +`; +}; + +module.exports = createAutocompleteExports; diff --git a/packages/kbn-monaco/scripts/utils/index.js b/packages/kbn-monaco/scripts/utils/index.js new file mode 100644 index 0000000000000..b38bbfe52d7cd --- /dev/null +++ b/packages/kbn-monaco/scripts/utils/index.js @@ -0,0 +1,28 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +const cloneAndCheckout = require('./clone_es'); +const { createAutocompleteDefinitions } = require('./create_autocomplete_definitions'); +const createAutocompleteExports = require('./create_autocomplete_exports'); + +module.exports = { + cloneAndCheckout, + createAutocompleteDefinitions, + createAutocompleteExports, +}; diff --git a/packages/kbn-monaco/src/index.ts b/packages/kbn-monaco/src/index.ts index 2a8467d6ef8fd..dcfcb5fbfc63f 100644 --- a/packages/kbn-monaco/src/index.ts +++ b/packages/kbn-monaco/src/index.ts @@ -22,7 +22,7 @@ import './register_globals'; export { monaco } from './monaco_imports'; export { XJsonLang } from './xjson'; -export { PainlessLang } from './painless'; +export { PainlessLang, PainlessContext } from './painless'; /* eslint-disable-next-line @kbn/eslint/module_migration */ import * as BarePluginApi from 'monaco-editor/esm/vs/editor/editor.api'; diff --git a/packages/kbn-monaco/src/painless/README.md b/packages/kbn-monaco/src/painless/README.md new file mode 100644 index 0000000000000..89980a43770ee --- /dev/null +++ b/packages/kbn-monaco/src/painless/README.md @@ -0,0 +1,105 @@ +# Painless + +This folder contains the language definitions for Painless used by the Monaco editor. + +## Summary of contents + +### ./language + +Initializes the worker proxy service when the Painless language is first needed. It also exports the [suggestion provider](https://microsoft.github.io/monaco-editor/api/interfaces/monaco.languages.completionitemprovider.html) needed for autocompletion. + +### ./services +This directory exports two services: + +1. Worker proxy: Responsible for holding a reference to the Monaco-provided proxy getter. +2. Editor state: Responsible for holding a reference to the current Painless context and fields provided as props via the React `` component. + +### ./completion_adapter + +Implements the monaco [CompletionItemProvider](https://microsoft.github.io/monaco-editor/api/interfaces/monaco.languages.completionitemprovider.html). Returns autocomplete suggestions based on the editor context and current characters. + +### ./constants + +Contains the unique language ID. + +### ./types + +Exports common Typescript interfaces. + +### ./lexer_rules + +Contains the Monarch-specific language tokenization rules for Painless. + +### ./worker + +The worker proxy and worker instantiation code used in both the main thread and the worker thread. The logic for providing autocomplete suggestions resides here. + +### ./autocomplete_definitions + +This directory is generated by a script and should not be changed manually. Read [Updating autocomplete definitions](#updating-autocomplete-definitions) for more information. + +## Example usage + +``` +import { PainlessLang, PainlessContext } from '@kbn/monaco'; +import { CodeEditor } from '../src/plugins/kibana_react/public'; + +// Fields are optional and only applicable in certain contexts +const fields = [ + { + name: 'field1', + type: 'float', + }, + { + name: 'field2', + type: 'boolean', + }, + { + name: 'field3', + type: 'boolean', + }, +]; + + +``` + +## Updating autocomplete definitions + +The autocomplete definitions are generated by the `kbn-monaco/scripts/generate_autocomplete.js` script. This script should be run each release to ensure the definitions are up-to-date. + +Run from the package root directory: + +``` +node scripts/generate_autocomplete --tag +# or +node scripts/generate_autocomplete --branch +``` + +**Note:** The script currently only generates autocomplete definitions for the following contexts: + + - `boolean_script_field_script_field` + - `date_script_field` + - `double_script_field_script_field` + - `filter` + - `ip_script_field_script_field` + - `long_script_field_script_field` + - `painless_test` + - `processor_conditional` + - `score` + - `string_script_field_script_field` + +To add additional contexts, edit the `supportedContexts` constant in `kbn-monaco/scripts/constants.js`. \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/boolean_script_field_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/boolean_script_field_script_field.json new file mode 100644 index 0000000000000..58680e02ba5c0 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/boolean_script_field_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.BooleanFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/date_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/date_script_field.json new file mode 100644 index 0000000000000..a5e9e35de5644 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/date_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.DateFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/double_script_field_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/double_script_field_script_field.json new file mode 100644 index 0000000000000..0e34d71737000 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/double_script_field_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.DoubleFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/filter.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/filter.json new file mode 100644 index 0000000000000..f96c4061b7608 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/filter.json @@ -0,0 +1,43978 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InternalEqlScriptUtils", + "kind": "class", + "documentation": "Class: InternalEqlScriptUtils", + "insertText": "InternalEqlScriptUtils", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.lang.String a, java.lang.String b, java.lang.String c, java.lang.Boolean d, java.lang.Boolean e): java.lang.String", + "insertText": "between" + }, + { + "label": "cidrMatch", + "kind": "method", + "documentation": "cidrMatch(java.lang.String a, java.util.List b): java.lang.Boolean", + "insertText": "cidrMatch" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.List a): java.lang.String", + "insertText": "concat" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a, java.lang.String b, java.lang.Boolean c): java.lang.Boolean", + "insertText": "endsWith" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, java.lang.String b, java.lang.Number c, java.lang.Boolean d): java.lang.Integer", + "insertText": "indexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(java.lang.String a): java.lang.Integer", + "insertText": "length" + }, + { + "label": "number", + "kind": "method", + "documentation": "number(java.lang.String a, java.lang.Number b): java.lang.Number", + "insertText": "number" + }, + { + "label": "seq", + "kind": "method", + "documentation": "seq(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "seq" + }, + { + "label": "sneq", + "kind": "method", + "documentation": "sneq(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "sneq" + }, + { + "label": "string", + "kind": "method", + "documentation": "string(java.lang.Object a): java.lang.String", + "insertText": "string" + }, + { + "label": "stringContains", + "kind": "method", + "documentation": "stringContains(java.lang.String a, java.lang.String b, java.lang.Boolean c): java.lang.Boolean", + "insertText": "stringContains" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(java.lang.String a, java.lang.Number b, java.lang.Number c): java.lang.String", + "insertText": "substring" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InternalQlScriptUtils", + "kind": "class", + "documentation": "Class: InternalQlScriptUtils", + "insertText": "InternalQlScriptUtils", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.lang.Boolean a, java.lang.Boolean b): java.lang.Boolean", + "insertText": "and" + }, + { + "label": "div", + "kind": "method", + "documentation": "div(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "div" + }, + { + "label": "docValue", + "kind": "method", + "documentation": "docValue(java.util.Map a, java.lang.String b): org.elasticsearch.painless.lookup.def", + "insertText": "docValue" + }, + { + "label": "eq", + "kind": "method", + "documentation": "eq(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "eq" + }, + { + "label": "gt", + "kind": "method", + "documentation": "gt(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "gt" + }, + { + "label": "gte", + "kind": "method", + "documentation": "gte(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "gte" + }, + { + "label": "in", + "kind": "method", + "documentation": "in(java.lang.Object a, java.util.List b): java.lang.Boolean", + "insertText": "in" + }, + { + "label": "isNotNull", + "kind": "method", + "documentation": "isNotNull(java.lang.Object a): java.lang.Boolean", + "insertText": "isNotNull" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): java.lang.Boolean", + "insertText": "isNull" + }, + { + "label": "lt", + "kind": "method", + "documentation": "lt(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "lt" + }, + { + "label": "lte", + "kind": "method", + "documentation": "lte(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "lte" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "mod" + }, + { + "label": "mul", + "kind": "method", + "documentation": "mul(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "mul" + }, + { + "label": "neg", + "kind": "method", + "documentation": "neg(java.lang.Number a): java.lang.Number", + "insertText": "neg" + }, + { + "label": "neq", + "kind": "method", + "documentation": "neq(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "neq" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(java.lang.Boolean a): java.lang.Boolean", + "insertText": "not" + }, + { + "label": "nullSafeFilter", + "kind": "method", + "documentation": "nullSafeFilter(java.lang.Boolean a): boolean", + "insertText": "nullSafeFilter" + }, + { + "label": "nullSafeSortNumeric", + "kind": "method", + "documentation": "nullSafeSortNumeric(java.lang.Number a): double", + "insertText": "nullSafeSortNumeric" + }, + { + "label": "nullSafeSortString", + "kind": "method", + "documentation": "nullSafeSortString(java.lang.Object a): java.lang.String", + "insertText": "nullSafeSortString" + }, + { + "label": "nulleq", + "kind": "method", + "documentation": "nulleq(java.lang.Object a, java.lang.Object b): java.lang.Boolean", + "insertText": "nulleq" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.lang.Boolean a, java.lang.Boolean b): java.lang.Boolean", + "insertText": "or" + }, + { + "label": "regex", + "kind": "method", + "documentation": "regex(java.lang.String a, java.lang.String b): java.lang.Boolean", + "insertText": "regex" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, java.lang.String b, java.lang.Boolean c): java.lang.Boolean", + "insertText": "startsWith" + }, + { + "label": "sub", + "kind": "method", + "documentation": "sub(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "sub" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InternalSqlScriptUtils", + "kind": "class", + "documentation": "Class: InternalSqlScriptUtils", + "insertText": "InternalSqlScriptUtils", + "properties": [ + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.lang.Number a): java.lang.Number", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(java.lang.Number a): java.lang.Number", + "insertText": "acos" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "add" + }, + { + "label": "asDateTime", + "kind": "method", + "documentation": "asDateTime(java.lang.Object a): java.time.ZonedDateTime", + "insertText": "asDateTime" + }, + { + "label": "asTime", + "kind": "method", + "documentation": "asTime(java.lang.String a): java.time.OffsetTime", + "insertText": "asTime" + }, + { + "label": "ascii", + "kind": "method", + "documentation": "ascii(java.lang.String a): java.lang.Integer", + "insertText": "ascii" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(java.lang.Number a): java.lang.Number", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(java.lang.Number a): java.lang.Number", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "atan2" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(java.lang.String a): java.lang.Integer", + "insertText": "bitLength" + }, + { + "label": "cast", + "kind": "method", + "documentation": "cast(java.lang.Object a, java.lang.String b): org.elasticsearch.painless.lookup.def", + "insertText": "cast" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(java.lang.Number a): java.lang.Number", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(java.lang.Number a): java.lang.Number", + "insertText": "ceil" + }, + { + "label": "charLength", + "kind": "method", + "documentation": "charLength(java.lang.String a): java.lang.Integer", + "insertText": "charLength" + }, + { + "label": "character", + "kind": "method", + "documentation": "character(java.lang.Number a): java.lang.String", + "insertText": "character" + }, + { + "label": "coalesce", + "kind": "method", + "documentation": "coalesce(java.util.List a): org.elasticsearch.painless.lookup.def", + "insertText": "coalesce" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a, java.lang.String b): java.lang.String", + "insertText": "concat" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(java.lang.Number a): java.lang.Number", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(java.lang.Number a): java.lang.Number", + "insertText": "cosh" + }, + { + "label": "cot", + "kind": "method", + "documentation": "cot(java.lang.Number a): java.lang.Number", + "insertText": "cot" + }, + { + "label": "dateAdd", + "kind": "method", + "documentation": "dateAdd(java.lang.String a, java.lang.Integer b, java.lang.Object c, java.lang.String d): java.time.ZonedDateTime", + "insertText": "dateAdd" + }, + { + "label": "dateDiff", + "kind": "method", + "documentation": "dateDiff(java.lang.String a, java.lang.Object b, java.lang.Object c, java.lang.String d): java.lang.Integer", + "insertText": "dateDiff" + }, + { + "label": "dateParse", + "kind": "method", + "documentation": "dateParse(java.lang.String a, java.lang.String b, java.lang.String c): org.elasticsearch.painless.lookup.def", + "insertText": "dateParse" + }, + { + "label": "datePart", + "kind": "method", + "documentation": "datePart(java.lang.String a, java.lang.Object b, java.lang.String c): java.lang.Integer", + "insertText": "datePart" + }, + { + "label": "dateTimeChrono", + "kind": "method", + "documentation": "dateTimeChrono(java.lang.Object a, java.lang.String b, java.lang.String c): java.lang.Integer", + "insertText": "dateTimeChrono" + }, + { + "label": "dateTimeFormat", + "kind": "method", + "documentation": "dateTimeFormat(java.lang.Object a, java.lang.String b, java.lang.String c): java.lang.String", + "insertText": "dateTimeFormat" + }, + { + "label": "dateTimeParse", + "kind": "method", + "documentation": "dateTimeParse(java.lang.String a, java.lang.String b, java.lang.String c): org.elasticsearch.painless.lookup.def", + "insertText": "dateTimeParse" + }, + { + "label": "dateTrunc", + "kind": "method", + "documentation": "dateTrunc(java.lang.String a, java.lang.Object b, java.lang.String c): org.elasticsearch.painless.lookup.def", + "insertText": "dateTrunc" + }, + { + "label": "dayName", + "kind": "method", + "documentation": "dayName(java.lang.Object a, java.lang.String b): java.lang.String", + "insertText": "dayName" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(java.lang.Object a, java.lang.String b): java.lang.Integer", + "insertText": "dayOfWeek" + }, + { + "label": "degrees", + "kind": "method", + "documentation": "degrees(java.lang.Number a): java.lang.Number", + "insertText": "degrees" + }, + { + "label": "div", + "kind": "method", + "documentation": "div(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "div" + }, + { + "label": "e", + "kind": "method", + "documentation": "e(java.lang.Number a): java.lang.Number", + "insertText": "e" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(java.lang.Number a): java.lang.Number", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(java.lang.Number a): java.lang.Number", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(java.lang.Number a): java.lang.Number", + "insertText": "floor" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.String b, java.lang.String c): java.lang.String", + "insertText": "format" + }, + { + "label": "geoDocValue", + "kind": "method", + "documentation": "geoDocValue(java.util.Map a, java.lang.String b): org.elasticsearch.xpack.sql.expression.literal.geo.GeoShape", + "insertText": "geoDocValue" + }, + { + "label": "greatest", + "kind": "method", + "documentation": "greatest(java.util.List a): org.elasticsearch.painless.lookup.def", + "insertText": "greatest" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(java.lang.String a, java.lang.Number b, java.lang.Number c, java.lang.String d): java.lang.String", + "insertText": "insert" + }, + { + "label": "intervalDayTime", + "kind": "method", + "documentation": "intervalDayTime(java.lang.String a, java.lang.String b): org.elasticsearch.xpack.sql.expression.literal.interval.IntervalDayTime", + "insertText": "intervalDayTime" + }, + { + "label": "intervalYearMonth", + "kind": "method", + "documentation": "intervalYearMonth(java.lang.String a, java.lang.String b): org.elasticsearch.xpack.sql.expression.literal.interval.IntervalYearMonth", + "insertText": "intervalYearMonth" + }, + { + "label": "lcase", + "kind": "method", + "documentation": "lcase(java.lang.String a): java.lang.String", + "insertText": "lcase" + }, + { + "label": "least", + "kind": "method", + "documentation": "least(java.util.List a): org.elasticsearch.painless.lookup.def", + "insertText": "least" + }, + { + "label": "left", + "kind": "method", + "documentation": "left(java.lang.String a, java.lang.Number b): java.lang.String", + "insertText": "left" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(java.lang.String a): java.lang.Integer", + "insertText": "length" + }, + { + "label": "locate", + "kind": "method", + "documentation": "locate(java.lang.String a, java.lang.String b, java.lang.Number c | java.lang.String a, java.lang.String b): java.lang.Integer", + "insertText": "locate" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(java.lang.Number a): java.lang.Number", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(java.lang.Number a): java.lang.Number", + "insertText": "log10" + }, + { + "label": "ltrim", + "kind": "method", + "documentation": "ltrim(java.lang.String a): java.lang.String", + "insertText": "ltrim" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "mod" + }, + { + "label": "monthName", + "kind": "method", + "documentation": "monthName(java.lang.Object a, java.lang.String b): java.lang.String", + "insertText": "monthName" + }, + { + "label": "mul", + "kind": "method", + "documentation": "mul(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "mul" + }, + { + "label": "neg", + "kind": "method", + "documentation": "neg(java.lang.Number a): java.lang.Number", + "insertText": "neg" + }, + { + "label": "nullif", + "kind": "method", + "documentation": "nullif(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "nullif" + }, + { + "label": "octetLength", + "kind": "method", + "documentation": "octetLength(java.lang.String a): java.lang.Integer", + "insertText": "octetLength" + }, + { + "label": "pi", + "kind": "method", + "documentation": "pi(java.lang.Number a): java.lang.Number", + "insertText": "pi" + }, + { + "label": "position", + "kind": "method", + "documentation": "position(java.lang.String a, java.lang.String b): java.lang.Integer", + "insertText": "position" + }, + { + "label": "power", + "kind": "method", + "documentation": "power(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "power" + }, + { + "label": "quarter", + "kind": "method", + "documentation": "quarter(java.lang.Object a, java.lang.String b): java.lang.Integer", + "insertText": "quarter" + }, + { + "label": "radians", + "kind": "method", + "documentation": "radians(java.lang.Number a): java.lang.Number", + "insertText": "radians" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(java.lang.Number a): java.lang.Number", + "insertText": "random" + }, + { + "label": "regex", + "kind": "method", + "documentation": "regex(java.lang.String a, java.lang.String b): java.lang.Boolean", + "insertText": "regex" + }, + { + "label": "repeat", + "kind": "method", + "documentation": "repeat(java.lang.String a, java.lang.Number b): java.lang.String", + "insertText": "repeat" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.String a, java.lang.String b, java.lang.String c): java.lang.String", + "insertText": "replace" + }, + { + "label": "right", + "kind": "method", + "documentation": "right(java.lang.String a, java.lang.Number b): java.lang.String", + "insertText": "right" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "round" + }, + { + "label": "rtrim", + "kind": "method", + "documentation": "rtrim(java.lang.String a): java.lang.String", + "insertText": "rtrim" + }, + { + "label": "sign", + "kind": "method", + "documentation": "sign(java.lang.Number a): java.lang.Number", + "insertText": "sign" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(java.lang.Number a): java.lang.Number", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(java.lang.Number a): java.lang.Number", + "insertText": "sinh" + }, + { + "label": "space", + "kind": "method", + "documentation": "space(java.lang.Number a): java.lang.String", + "insertText": "space" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(java.lang.Number a): java.lang.Number", + "insertText": "sqrt" + }, + { + "label": "stAswkt", + "kind": "method", + "documentation": "stAswkt(java.lang.Object a): java.lang.String", + "insertText": "stAswkt" + }, + { + "label": "stDistance", + "kind": "method", + "documentation": "stDistance(java.lang.Object a, java.lang.Object b): java.lang.Double", + "insertText": "stDistance" + }, + { + "label": "stGeometryType", + "kind": "method", + "documentation": "stGeometryType(java.lang.Object a): java.lang.String", + "insertText": "stGeometryType" + }, + { + "label": "stWktToSql", + "kind": "method", + "documentation": "stWktToSql(java.lang.String a): org.elasticsearch.xpack.sql.expression.literal.geo.GeoShape", + "insertText": "stWktToSql" + }, + { + "label": "stX", + "kind": "method", + "documentation": "stX(java.lang.Object a): java.lang.Double", + "insertText": "stX" + }, + { + "label": "stY", + "kind": "method", + "documentation": "stY(java.lang.Object a): java.lang.Double", + "insertText": "stY" + }, + { + "label": "stZ", + "kind": "method", + "documentation": "stZ(java.lang.Object a): java.lang.Double", + "insertText": "stZ" + }, + { + "label": "sub", + "kind": "method", + "documentation": "sub(java.lang.Object a, java.lang.Object b): org.elasticsearch.painless.lookup.def", + "insertText": "sub" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(java.lang.String a, java.lang.Number b, java.lang.Number c): java.lang.String", + "insertText": "substring" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(java.lang.Number a): java.lang.Number", + "insertText": "tan" + }, + { + "label": "timeParse", + "kind": "method", + "documentation": "timeParse(java.lang.String a, java.lang.String b, java.lang.String c): org.elasticsearch.painless.lookup.def", + "insertText": "timeParse" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(java.lang.String a): java.lang.String", + "insertText": "trim" + }, + { + "label": "truncate", + "kind": "method", + "documentation": "truncate(java.lang.Number a, java.lang.Number b): java.lang.Number", + "insertText": "truncate" + }, + { + "label": "ucase", + "kind": "method", + "documentation": "ucase(java.lang.String a): java.lang.String", + "insertText": "ucase" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(java.lang.Object a, java.lang.String b): java.lang.Integer", + "insertText": "weekOfYear" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "GeoShape", + "kind": "class", + "documentation": "Class: GeoShape", + "insertText": "GeoShape", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalDayTime", + "kind": "class", + "documentation": "Class: IntervalDayTime", + "insertText": "IntervalDayTime", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalYearMonth", + "kind": "class", + "documentation": "Class: IntervalYearMonth", + "insertText": "IntervalYearMonth", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsignedLongScriptDocValues", + "kind": "class", + "documentation": "Class: UnsignedLongScriptDocValues", + "insertText": "UnsignedLongScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Number", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.Number", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "VersionScriptDocValues", + "kind": "class", + "documentation": "Class: VersionScriptDocValues", + "insertText": "VersionScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/index.ts b/packages/kbn-monaco/src/painless/autocomplete_definitions/index.ts new file mode 100644 index 0000000000000..4bf82f27163ca --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/index.ts @@ -0,0 +1,39 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ +// DO NOT EDIT: THIS FILE CONTAINS GENERATED CODE. REFER TO THE PAINLESS README FOR MORE INFORMATION. +import * as stringScriptFieldScriptFieldContext from './string_script_field_script_field.json'; +import * as scoreContext from './score.json'; +import * as processorConditionalContext from './processor_conditional.json'; +import * as painlessTestContext from './painless_test.json'; +import * as longScriptFieldScriptFieldContext from './long_script_field_script_field.json'; +import * as ipScriptFieldScriptFieldContext from './ip_script_field_script_field.json'; +import * as filterContext from './filter.json'; +import * as doubleScriptFieldScriptFieldContext from './double_script_field_script_field.json'; +import * as dateScriptFieldContext from './date_script_field.json'; +import * as booleanScriptFieldScriptFieldContext from './boolean_script_field_script_field.json'; +export { stringScriptFieldScriptFieldContext }; +export { scoreContext }; +export { processorConditionalContext }; +export { painlessTestContext }; +export { longScriptFieldScriptFieldContext }; +export { ipScriptFieldScriptFieldContext }; +export { filterContext }; +export { doubleScriptFieldScriptFieldContext }; +export { dateScriptFieldContext }; +export { booleanScriptFieldScriptFieldContext }; diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/ip_script_field_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/ip_script_field_script_field.json new file mode 100644 index 0000000000000..dbe4541a6edf6 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/ip_script_field_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.IpFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/long_script_field_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/long_script_field_script_field.json new file mode 100644 index 0000000000000..fbdf70e40e217 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/long_script_field_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.LongFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/painless_test.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/painless_test.json new file mode 100644 index 0000000000000..53ca674b3f870 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/painless_test.json @@ -0,0 +1,42516 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/processor_conditional.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/processor_conditional.json new file mode 100644 index 0000000000000..53ca674b3f870 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/processor_conditional.json @@ -0,0 +1,42516 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/score.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/score.json new file mode 100644 index 0000000000000..6dcf8789603e0 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/score.json @@ -0,0 +1,43370 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "org.elasticsearch.script.ScoreScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.script.ScoreScript", + "insertText": "org.elasticsearch.script.ScoreScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsignedLongScriptDocValues", + "kind": "class", + "documentation": "Class: UnsignedLongScriptDocValues", + "insertText": "UnsignedLongScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Number", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.Number", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DenseVectorScriptDocValues", + "kind": "class", + "documentation": "Class: DenseVectorScriptDocValues", + "insertText": "DenseVectorScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "VersionScriptDocValues", + "kind": "class", + "documentation": "Class: VersionScriptDocValues", + "insertText": "VersionScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/autocomplete_definitions/string_script_field_script_field.json b/packages/kbn-monaco/src/painless/autocomplete_definitions/string_script_field_script_field.json new file mode 100644 index 0000000000000..31625de795320 --- /dev/null +++ b/packages/kbn-monaco/src/painless/autocomplete_definitions/string_script_field_script_field.json @@ -0,0 +1,42568 @@ +{ + "suggestions": [ + { + "label": "boolean", + "kind": "type", + "documentation": "Primitive: boolean", + "insertText": "boolean" + }, + { + "label": "byte", + "kind": "type", + "documentation": "Primitive: byte", + "insertText": "byte" + }, + { + "label": "char", + "kind": "type", + "documentation": "Primitive: char", + "insertText": "char" + }, + { + "label": "double", + "kind": "type", + "documentation": "Primitive: double", + "insertText": "double" + }, + { + "label": "float", + "kind": "type", + "documentation": "Primitive: float", + "insertText": "float" + }, + { + "label": "int", + "kind": "type", + "documentation": "Primitive: int", + "insertText": "int" + }, + { + "label": "Appendable", + "kind": "class", + "documentation": "Class: Appendable", + "insertText": "Appendable", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c): java.lang.Appendable", + "insertText": "append" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArithmeticException", + "kind": "class", + "documentation": "Class: ArithmeticException", + "insertText": "ArithmeticException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArithmeticException", + "kind": "constructor", + "documentation": "Constructor: ArithmeticException", + "insertText": "ArithmeticException" + } + }, + { + "label": "ArrayIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: ArrayIndexOutOfBoundsException", + "insertText": "ArrayIndexOutOfBoundsException" + } + }, + { + "label": "ArrayStoreException", + "kind": "class", + "documentation": "Class: ArrayStoreException", + "insertText": "ArrayStoreException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayStoreException", + "kind": "constructor", + "documentation": "Constructor: ArrayStoreException", + "insertText": "ArrayStoreException" + } + }, + { + "label": "Boolean", + "kind": "class", + "documentation": "Class: Boolean", + "insertText": "Boolean", + "properties": [ + { + "label": "FALSE", + "kind": "property", + "documentation": "FALSE: java.lang.Boolean", + "insertText": "FALSE" + }, + { + "label": "TRUE", + "kind": "property", + "documentation": "TRUE: java.lang.Boolean", + "insertText": "TRUE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(boolean a, boolean b): int", + "insertText": "compare" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(boolean a): int", + "insertText": "hashCode" + }, + { + "label": "logicalAnd", + "kind": "method", + "documentation": "logicalAnd(boolean a, boolean b): boolean", + "insertText": "logicalAnd" + }, + { + "label": "logicalOr", + "kind": "method", + "documentation": "logicalOr(boolean a, boolean b): boolean", + "insertText": "logicalOr" + }, + { + "label": "logicalXor", + "kind": "method", + "documentation": "logicalXor(boolean a, boolean b): boolean", + "insertText": "logicalXor" + }, + { + "label": "parseBoolean", + "kind": "method", + "documentation": "parseBoolean(java.lang.String a): boolean", + "insertText": "parseBoolean" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(boolean a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(boolean a): java.lang.Boolean", + "insertText": "valueOf" + }, + { + "label": "booleanValue", + "kind": "method", + "documentation": "booleanValue(): boolean", + "insertText": "booleanValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Boolean a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Byte", + "kind": "class", + "documentation": "Class: Byte", + "insertText": "Byte", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: byte", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: byte", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(byte a, byte b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Byte", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(byte a): int", + "insertText": "hashCode" + }, + { + "label": "parseByte", + "kind": "method", + "documentation": "parseByte(java.lang.String a, int b | java.lang.String a): byte", + "insertText": "parseByte" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(byte a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(byte a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(byte a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | byte a): java.lang.Byte", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Byte a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharSequence", + "kind": "class", + "documentation": "Class: CharSequence", + "insertText": "CharSequence", + "properties": [ + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character", + "kind": "class", + "documentation": "Class: Character", + "insertText": "Character", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "COMBINING_SPACING_MARK", + "kind": "property", + "documentation": "COMBINING_SPACING_MARK: byte", + "insertText": "COMBINING_SPACING_MARK" + }, + { + "label": "CONNECTOR_PUNCTUATION", + "kind": "property", + "documentation": "CONNECTOR_PUNCTUATION: byte", + "insertText": "CONNECTOR_PUNCTUATION" + }, + { + "label": "CONTROL", + "kind": "property", + "documentation": "CONTROL: byte", + "insertText": "CONTROL" + }, + { + "label": "CURRENCY_SYMBOL", + "kind": "property", + "documentation": "CURRENCY_SYMBOL: byte", + "insertText": "CURRENCY_SYMBOL" + }, + { + "label": "DASH_PUNCTUATION", + "kind": "property", + "documentation": "DASH_PUNCTUATION: byte", + "insertText": "DASH_PUNCTUATION" + }, + { + "label": "DECIMAL_DIGIT_NUMBER", + "kind": "property", + "documentation": "DECIMAL_DIGIT_NUMBER: byte", + "insertText": "DECIMAL_DIGIT_NUMBER" + }, + { + "label": "DIRECTIONALITY_ARABIC_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_ARABIC_NUMBER: byte", + "insertText": "DIRECTIONALITY_ARABIC_NUMBER" + }, + { + "label": "DIRECTIONALITY_BOUNDARY_NEUTRAL", + "kind": "property", + "documentation": "DIRECTIONALITY_BOUNDARY_NEUTRAL: byte", + "insertText": "DIRECTIONALITY_BOUNDARY_NEUTRAL" + }, + { + "label": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: byte", + "insertText": "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_NONSPACING_MARK", + "kind": "property", + "documentation": "DIRECTIONALITY_NONSPACING_MARK: byte", + "insertText": "DIRECTIONALITY_NONSPACING_MARK" + }, + { + "label": "DIRECTIONALITY_OTHER_NEUTRALS", + "kind": "property", + "documentation": "DIRECTIONALITY_OTHER_NEUTRALS: byte", + "insertText": "DIRECTIONALITY_OTHER_NEUTRALS" + }, + { + "label": "DIRECTIONALITY_PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_PARAGRAPH_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_PARAGRAPH_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT", + "kind": "property", + "documentation": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: byte", + "insertText": "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING" + }, + { + "label": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE", + "kind": "property", + "documentation": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: byte", + "insertText": "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE" + }, + { + "label": "DIRECTIONALITY_SEGMENT_SEPARATOR", + "kind": "property", + "documentation": "DIRECTIONALITY_SEGMENT_SEPARATOR: byte", + "insertText": "DIRECTIONALITY_SEGMENT_SEPARATOR" + }, + { + "label": "DIRECTIONALITY_UNDEFINED", + "kind": "property", + "documentation": "DIRECTIONALITY_UNDEFINED: byte", + "insertText": "DIRECTIONALITY_UNDEFINED" + }, + { + "label": "DIRECTIONALITY_WHITESPACE", + "kind": "property", + "documentation": "DIRECTIONALITY_WHITESPACE: byte", + "insertText": "DIRECTIONALITY_WHITESPACE" + }, + { + "label": "ENCLOSING_MARK", + "kind": "property", + "documentation": "ENCLOSING_MARK: byte", + "insertText": "ENCLOSING_MARK" + }, + { + "label": "END_PUNCTUATION", + "kind": "property", + "documentation": "END_PUNCTUATION: byte", + "insertText": "END_PUNCTUATION" + }, + { + "label": "FINAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "FINAL_QUOTE_PUNCTUATION: byte", + "insertText": "FINAL_QUOTE_PUNCTUATION" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: byte", + "insertText": "FORMAT" + }, + { + "label": "INITIAL_QUOTE_PUNCTUATION", + "kind": "property", + "documentation": "INITIAL_QUOTE_PUNCTUATION: byte", + "insertText": "INITIAL_QUOTE_PUNCTUATION" + }, + { + "label": "LETTER_NUMBER", + "kind": "property", + "documentation": "LETTER_NUMBER: byte", + "insertText": "LETTER_NUMBER" + }, + { + "label": "LINE_SEPARATOR", + "kind": "property", + "documentation": "LINE_SEPARATOR: byte", + "insertText": "LINE_SEPARATOR" + }, + { + "label": "LOWERCASE_LETTER", + "kind": "property", + "documentation": "LOWERCASE_LETTER: byte", + "insertText": "LOWERCASE_LETTER" + }, + { + "label": "MATH_SYMBOL", + "kind": "property", + "documentation": "MATH_SYMBOL: byte", + "insertText": "MATH_SYMBOL" + }, + { + "label": "MAX_CODE_POINT", + "kind": "property", + "documentation": "MAX_CODE_POINT: int", + "insertText": "MAX_CODE_POINT" + }, + { + "label": "MAX_HIGH_SURROGATE", + "kind": "property", + "documentation": "MAX_HIGH_SURROGATE: char", + "insertText": "MAX_HIGH_SURROGATE" + }, + { + "label": "MAX_LOW_SURROGATE", + "kind": "property", + "documentation": "MAX_LOW_SURROGATE: char", + "insertText": "MAX_LOW_SURROGATE" + }, + { + "label": "MAX_RADIX", + "kind": "property", + "documentation": "MAX_RADIX: int", + "insertText": "MAX_RADIX" + }, + { + "label": "MAX_SURROGATE", + "kind": "property", + "documentation": "MAX_SURROGATE: char", + "insertText": "MAX_SURROGATE" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: char", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_CODE_POINT", + "kind": "property", + "documentation": "MIN_CODE_POINT: int", + "insertText": "MIN_CODE_POINT" + }, + { + "label": "MIN_HIGH_SURROGATE", + "kind": "property", + "documentation": "MIN_HIGH_SURROGATE: char", + "insertText": "MIN_HIGH_SURROGATE" + }, + { + "label": "MIN_LOW_SURROGATE", + "kind": "property", + "documentation": "MIN_LOW_SURROGATE: char", + "insertText": "MIN_LOW_SURROGATE" + }, + { + "label": "MIN_RADIX", + "kind": "property", + "documentation": "MIN_RADIX: int", + "insertText": "MIN_RADIX" + }, + { + "label": "MIN_SUPPLEMENTARY_CODE_POINT", + "kind": "property", + "documentation": "MIN_SUPPLEMENTARY_CODE_POINT: int", + "insertText": "MIN_SUPPLEMENTARY_CODE_POINT" + }, + { + "label": "MIN_SURROGATE", + "kind": "property", + "documentation": "MIN_SURROGATE: char", + "insertText": "MIN_SURROGATE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: char", + "insertText": "MIN_VALUE" + }, + { + "label": "MODIFIER_LETTER", + "kind": "property", + "documentation": "MODIFIER_LETTER: byte", + "insertText": "MODIFIER_LETTER" + }, + { + "label": "MODIFIER_SYMBOL", + "kind": "property", + "documentation": "MODIFIER_SYMBOL: byte", + "insertText": "MODIFIER_SYMBOL" + }, + { + "label": "NON_SPACING_MARK", + "kind": "property", + "documentation": "NON_SPACING_MARK: byte", + "insertText": "NON_SPACING_MARK" + }, + { + "label": "OTHER_LETTER", + "kind": "property", + "documentation": "OTHER_LETTER: byte", + "insertText": "OTHER_LETTER" + }, + { + "label": "OTHER_NUMBER", + "kind": "property", + "documentation": "OTHER_NUMBER: byte", + "insertText": "OTHER_NUMBER" + }, + { + "label": "OTHER_PUNCTUATION", + "kind": "property", + "documentation": "OTHER_PUNCTUATION: byte", + "insertText": "OTHER_PUNCTUATION" + }, + { + "label": "OTHER_SYMBOL", + "kind": "property", + "documentation": "OTHER_SYMBOL: byte", + "insertText": "OTHER_SYMBOL" + }, + { + "label": "PARAGRAPH_SEPARATOR", + "kind": "property", + "documentation": "PARAGRAPH_SEPARATOR: byte", + "insertText": "PARAGRAPH_SEPARATOR" + }, + { + "label": "PRIVATE_USE", + "kind": "property", + "documentation": "PRIVATE_USE: byte", + "insertText": "PRIVATE_USE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "SPACE_SEPARATOR", + "kind": "property", + "documentation": "SPACE_SEPARATOR: byte", + "insertText": "SPACE_SEPARATOR" + }, + { + "label": "START_PUNCTUATION", + "kind": "property", + "documentation": "START_PUNCTUATION: byte", + "insertText": "START_PUNCTUATION" + }, + { + "label": "SURROGATE", + "kind": "property", + "documentation": "SURROGATE: byte", + "insertText": "SURROGATE" + }, + { + "label": "TITLECASE_LETTER", + "kind": "property", + "documentation": "TITLECASE_LETTER: byte", + "insertText": "TITLECASE_LETTER" + }, + { + "label": "UNASSIGNED", + "kind": "property", + "documentation": "UNASSIGNED: byte", + "insertText": "UNASSIGNED" + }, + { + "label": "UPPERCASE_LETTER", + "kind": "property", + "documentation": "UPPERCASE_LETTER: byte", + "insertText": "UPPERCASE_LETTER" + }, + { + "label": "charCount", + "kind": "method", + "documentation": "charCount(int a): int", + "insertText": "charCount" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore([C a, int b, int c | java.lang.CharSequence a, int b): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(java.lang.CharSequence a, int b, int c): int", + "insertText": "codePointCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(char a, char b): int", + "insertText": "compare" + }, + { + "label": "digit", + "kind": "method", + "documentation": "digit(int a, int b): int", + "insertText": "digit" + }, + { + "label": "forDigit", + "kind": "method", + "documentation": "forDigit(int a, int b): char", + "insertText": "forDigit" + }, + { + "label": "getDirectionality", + "kind": "method", + "documentation": "getDirectionality(int a): byte", + "insertText": "getDirectionality" + }, + { + "label": "getName", + "kind": "method", + "documentation": "getName(int a): java.lang.String", + "insertText": "getName" + }, + { + "label": "getNumericValue", + "kind": "method", + "documentation": "getNumericValue(int a): int", + "insertText": "getNumericValue" + }, + { + "label": "getType", + "kind": "method", + "documentation": "getType(int a): int", + "insertText": "getType" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(char a): int", + "insertText": "hashCode" + }, + { + "label": "highSurrogate", + "kind": "method", + "documentation": "highSurrogate(int a): char", + "insertText": "highSurrogate" + }, + { + "label": "isAlphabetic", + "kind": "method", + "documentation": "isAlphabetic(int a): boolean", + "insertText": "isAlphabetic" + }, + { + "label": "isBmpCodePoint", + "kind": "method", + "documentation": "isBmpCodePoint(int a): boolean", + "insertText": "isBmpCodePoint" + }, + { + "label": "isDefined", + "kind": "method", + "documentation": "isDefined(int a): boolean", + "insertText": "isDefined" + }, + { + "label": "isDigit", + "kind": "method", + "documentation": "isDigit(int a): boolean", + "insertText": "isDigit" + }, + { + "label": "isHighSurrogate", + "kind": "method", + "documentation": "isHighSurrogate(char a): boolean", + "insertText": "isHighSurrogate" + }, + { + "label": "isISOControl", + "kind": "method", + "documentation": "isISOControl(int a): boolean", + "insertText": "isISOControl" + }, + { + "label": "isIdentifierIgnorable", + "kind": "method", + "documentation": "isIdentifierIgnorable(int a): boolean", + "insertText": "isIdentifierIgnorable" + }, + { + "label": "isIdeographic", + "kind": "method", + "documentation": "isIdeographic(int a): boolean", + "insertText": "isIdeographic" + }, + { + "label": "isJavaIdentifierPart", + "kind": "method", + "documentation": "isJavaIdentifierPart(int a): boolean", + "insertText": "isJavaIdentifierPart" + }, + { + "label": "isJavaIdentifierStart", + "kind": "method", + "documentation": "isJavaIdentifierStart(int a): boolean", + "insertText": "isJavaIdentifierStart" + }, + { + "label": "isLetter", + "kind": "method", + "documentation": "isLetter(int a): boolean", + "insertText": "isLetter" + }, + { + "label": "isLetterOrDigit", + "kind": "method", + "documentation": "isLetterOrDigit(int a): boolean", + "insertText": "isLetterOrDigit" + }, + { + "label": "isLowerCase", + "kind": "method", + "documentation": "isLowerCase(int a): boolean", + "insertText": "isLowerCase" + }, + { + "label": "isMirrored", + "kind": "method", + "documentation": "isMirrored(int a): boolean", + "insertText": "isMirrored" + }, + { + "label": "isSpaceChar", + "kind": "method", + "documentation": "isSpaceChar(int a): boolean", + "insertText": "isSpaceChar" + }, + { + "label": "isSupplementaryCodePoint", + "kind": "method", + "documentation": "isSupplementaryCodePoint(int a): boolean", + "insertText": "isSupplementaryCodePoint" + }, + { + "label": "isSurrogate", + "kind": "method", + "documentation": "isSurrogate(char a): boolean", + "insertText": "isSurrogate" + }, + { + "label": "isSurrogatePair", + "kind": "method", + "documentation": "isSurrogatePair(char a, char b): boolean", + "insertText": "isSurrogatePair" + }, + { + "label": "isTitleCase", + "kind": "method", + "documentation": "isTitleCase(int a): boolean", + "insertText": "isTitleCase" + }, + { + "label": "isUnicodeIdentifierPart", + "kind": "method", + "documentation": "isUnicodeIdentifierPart(int a): boolean", + "insertText": "isUnicodeIdentifierPart" + }, + { + "label": "isUnicodeIdentifierStart", + "kind": "method", + "documentation": "isUnicodeIdentifierStart(int a): boolean", + "insertText": "isUnicodeIdentifierStart" + }, + { + "label": "isUpperCase", + "kind": "method", + "documentation": "isUpperCase(int a): boolean", + "insertText": "isUpperCase" + }, + { + "label": "isValidCodePoint", + "kind": "method", + "documentation": "isValidCodePoint(int a): boolean", + "insertText": "isValidCodePoint" + }, + { + "label": "isWhitespace", + "kind": "method", + "documentation": "isWhitespace(int a): boolean", + "insertText": "isWhitespace" + }, + { + "label": "lowSurrogate", + "kind": "method", + "documentation": "lowSurrogate(int a): char", + "insertText": "lowSurrogate" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints([C a, int b, int c, int d, int e | java.lang.CharSequence a, int b, int c): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(char a): char", + "insertText": "reverseBytes" + }, + { + "label": "toChars", + "kind": "method", + "documentation": "toChars(int a, [C b, int c | int a): int | [C", + "insertText": "toChars" + }, + { + "label": "toCodePoint", + "kind": "method", + "documentation": "toCodePoint(char a, char b): int", + "insertText": "toCodePoint" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(char a): char", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(char a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTitleCase", + "kind": "method", + "documentation": "toTitleCase(char a): char", + "insertText": "toTitleCase" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(char a): char", + "insertText": "toUpperCase" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(char a): java.lang.Character", + "insertText": "valueOf" + }, + { + "label": "charValue", + "kind": "method", + "documentation": "charValue(): char", + "insertText": "charValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Character a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.Subset", + "kind": "class", + "documentation": "Class: Character.Subset", + "insertText": "Character.Subset", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeBlock", + "kind": "class", + "documentation": "Class: Character.UnicodeBlock", + "insertText": "Character.UnicodeBlock", + "properties": [ + { + "label": "AEGEAN_NUMBERS", + "kind": "property", + "documentation": "AEGEAN_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "AEGEAN_NUMBERS" + }, + { + "label": "ALCHEMICAL_SYMBOLS", + "kind": "property", + "documentation": "ALCHEMICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ALCHEMICAL_SYMBOLS" + }, + { + "label": "ALPHABETIC_PRESENTATION_FORMS", + "kind": "property", + "documentation": "ALPHABETIC_PRESENTATION_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "ALPHABETIC_PRESENTATION_FORMS" + }, + { + "label": "ANCIENT_GREEK_MUSICAL_NOTATION", + "kind": "property", + "documentation": "ANCIENT_GREEK_MUSICAL_NOTATION: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_MUSICAL_NOTATION" + }, + { + "label": "ANCIENT_GREEK_NUMBERS", + "kind": "property", + "documentation": "ANCIENT_GREEK_NUMBERS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_GREEK_NUMBERS" + }, + { + "label": "ANCIENT_SYMBOLS", + "kind": "property", + "documentation": "ANCIENT_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ANCIENT_SYMBOLS" + }, + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC" + }, + { + "label": "ARABIC_EXTENDED_A", + "kind": "property", + "documentation": "ARABIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_EXTENDED_A" + }, + { + "label": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", + "kind": "property", + "documentation": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_A", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_A: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_A" + }, + { + "label": "ARABIC_PRESENTATION_FORMS_B", + "kind": "property", + "documentation": "ARABIC_PRESENTATION_FORMS_B: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_PRESENTATION_FORMS_B" + }, + { + "label": "ARABIC_SUPPLEMENT", + "kind": "property", + "documentation": "ARABIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ARABIC_SUPPLEMENT" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeBlock", + "insertText": "ARMENIAN" + }, + { + "label": "ARROWS", + "kind": "property", + "documentation": "ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "ARROWS" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeBlock", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeBlock", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM" + }, + { + "label": "BAMUM_SUPPLEMENT", + "kind": "property", + "documentation": "BAMUM_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "BAMUM_SUPPLEMENT" + }, + { + "label": "BASIC_LATIN", + "kind": "property", + "documentation": "BASIC_LATIN: java.lang.Character$UnicodeBlock", + "insertText": "BASIC_LATIN" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeBlock", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeBlock", + "insertText": "BENGALI" + }, + { + "label": "BLOCK_ELEMENTS", + "kind": "property", + "documentation": "BLOCK_ELEMENTS: java.lang.Character$UnicodeBlock", + "insertText": "BLOCK_ELEMENTS" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO" + }, + { + "label": "BOPOMOFO_EXTENDED", + "kind": "property", + "documentation": "BOPOMOFO_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "BOPOMOFO_EXTENDED" + }, + { + "label": "BOX_DRAWING", + "kind": "property", + "documentation": "BOX_DRAWING: java.lang.Character$UnicodeBlock", + "insertText": "BOX_DRAWING" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeBlock", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE_PATTERNS", + "kind": "property", + "documentation": "BRAILLE_PATTERNS: java.lang.Character$UnicodeBlock", + "insertText": "BRAILLE_PATTERNS" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeBlock", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeBlock", + "insertText": "BUHID" + }, + { + "label": "BYZANTINE_MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "BYZANTINE_MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "BYZANTINE_MUSICAL_SYMBOLS" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeBlock", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeBlock", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeBlock", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeBlock", + "insertText": "CHEROKEE" + }, + { + "label": "CJK_COMPATIBILITY", + "kind": "property", + "documentation": "CJK_COMPATIBILITY: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY" + }, + { + "label": "CJK_COMPATIBILITY_FORMS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_FORMS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS" + }, + { + "label": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT" + }, + { + "label": "CJK_RADICALS_SUPPLEMENT", + "kind": "property", + "documentation": "CJK_RADICALS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "CJK_RADICALS_SUPPLEMENT" + }, + { + "label": "CJK_STROKES", + "kind": "property", + "documentation": "CJK_STROKES: java.lang.Character$UnicodeBlock", + "insertText": "CJK_STROKES" + }, + { + "label": "CJK_SYMBOLS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CJK_SYMBOLS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CJK_SYMBOLS_AND_PUNCTUATION" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C" + }, + { + "label": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", + "kind": "property", + "documentation": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: java.lang.Character$UnicodeBlock", + "insertText": "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS" + }, + { + "label": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", + "kind": "property", + "documentation": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT" + }, + { + "label": "COMBINING_HALF_MARKS", + "kind": "property", + "documentation": "COMBINING_HALF_MARKS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_HALF_MARKS" + }, + { + "label": "COMBINING_MARKS_FOR_SYMBOLS", + "kind": "property", + "documentation": "COMBINING_MARKS_FOR_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "COMBINING_MARKS_FOR_SYMBOLS" + }, + { + "label": "COMMON_INDIC_NUMBER_FORMS", + "kind": "property", + "documentation": "COMMON_INDIC_NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "COMMON_INDIC_NUMBER_FORMS" + }, + { + "label": "CONTROL_PICTURES", + "kind": "property", + "documentation": "CONTROL_PICTURES: java.lang.Character$UnicodeBlock", + "insertText": "CONTROL_PICTURES" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeBlock", + "insertText": "COPTIC" + }, + { + "label": "COUNTING_ROD_NUMERALS", + "kind": "property", + "documentation": "COUNTING_ROD_NUMERALS: java.lang.Character$UnicodeBlock", + "insertText": "COUNTING_ROD_NUMERALS" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM" + }, + { + "label": "CUNEIFORM_NUMBERS_AND_PUNCTUATION", + "kind": "property", + "documentation": "CUNEIFORM_NUMBERS_AND_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "CUNEIFORM_NUMBERS_AND_PUNCTUATION" + }, + { + "label": "CURRENCY_SYMBOLS", + "kind": "property", + "documentation": "CURRENCY_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "CURRENCY_SYMBOLS" + }, + { + "label": "CYPRIOT_SYLLABARY", + "kind": "property", + "documentation": "CYPRIOT_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "CYPRIOT_SYLLABARY" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC" + }, + { + "label": "CYRILLIC_EXTENDED_A", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_A" + }, + { + "label": "CYRILLIC_EXTENDED_B", + "kind": "property", + "documentation": "CYRILLIC_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_EXTENDED_B" + }, + { + "label": "CYRILLIC_SUPPLEMENTARY", + "kind": "property", + "documentation": "CYRILLIC_SUPPLEMENTARY: java.lang.Character$UnicodeBlock", + "insertText": "CYRILLIC_SUPPLEMENTARY" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeBlock", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI" + }, + { + "label": "DEVANAGARI_EXTENDED", + "kind": "property", + "documentation": "DEVANAGARI_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "DEVANAGARI_EXTENDED" + }, + { + "label": "DINGBATS", + "kind": "property", + "documentation": "DINGBATS: java.lang.Character$UnicodeBlock", + "insertText": "DINGBATS" + }, + { + "label": "DOMINO_TILES", + "kind": "property", + "documentation": "DOMINO_TILES: java.lang.Character$UnicodeBlock", + "insertText": "DOMINO_TILES" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "EMOTICONS", + "kind": "property", + "documentation": "EMOTICONS: java.lang.Character$UnicodeBlock", + "insertText": "EMOTICONS" + }, + { + "label": "ENCLOSED_ALPHANUMERICS", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERICS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERICS" + }, + { + "label": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_ALPHANUMERIC_SUPPLEMENT" + }, + { + "label": "ENCLOSED_CJK_LETTERS_AND_MONTHS", + "kind": "property", + "documentation": "ENCLOSED_CJK_LETTERS_AND_MONTHS: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_CJK_LETTERS_AND_MONTHS" + }, + { + "label": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", + "kind": "property", + "documentation": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC" + }, + { + "label": "ETHIOPIC_EXTENDED", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED" + }, + { + "label": "ETHIOPIC_EXTENDED_A", + "kind": "property", + "documentation": "ETHIOPIC_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_EXTENDED_A" + }, + { + "label": "ETHIOPIC_SUPPLEMENT", + "kind": "property", + "documentation": "ETHIOPIC_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "ETHIOPIC_SUPPLEMENT" + }, + { + "label": "GENERAL_PUNCTUATION", + "kind": "property", + "documentation": "GENERAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "GENERAL_PUNCTUATION" + }, + { + "label": "GEOMETRIC_SHAPES", + "kind": "property", + "documentation": "GEOMETRIC_SHAPES: java.lang.Character$UnicodeBlock", + "insertText": "GEOMETRIC_SHAPES" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN" + }, + { + "label": "GEORGIAN_SUPPLEMENT", + "kind": "property", + "documentation": "GEORGIAN_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "GEORGIAN_SUPPLEMENT" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeBlock", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeBlock", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeBlock", + "insertText": "GREEK" + }, + { + "label": "GREEK_EXTENDED", + "kind": "property", + "documentation": "GREEK_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "GREEK_EXTENDED" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeBlock", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeBlock", + "insertText": "GURMUKHI" + }, + { + "label": "HALFWIDTH_AND_FULLWIDTH_FORMS", + "kind": "property", + "documentation": "HALFWIDTH_AND_FULLWIDTH_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "HALFWIDTH_AND_FULLWIDTH_FORMS" + }, + { + "label": "HANGUL_COMPATIBILITY_JAMO", + "kind": "property", + "documentation": "HANGUL_COMPATIBILITY_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_COMPATIBILITY_JAMO" + }, + { + "label": "HANGUL_JAMO", + "kind": "property", + "documentation": "HANGUL_JAMO: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO" + }, + { + "label": "HANGUL_JAMO_EXTENDED_A", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_A" + }, + { + "label": "HANGUL_JAMO_EXTENDED_B", + "kind": "property", + "documentation": "HANGUL_JAMO_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_JAMO_EXTENDED_B" + }, + { + "label": "HANGUL_SYLLABLES", + "kind": "property", + "documentation": "HANGUL_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "HANGUL_SYLLABLES" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeBlock", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeBlock", + "insertText": "HEBREW" + }, + { + "label": "HIGH_PRIVATE_USE_SURROGATES", + "kind": "property", + "documentation": "HIGH_PRIVATE_USE_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_PRIVATE_USE_SURROGATES" + }, + { + "label": "HIGH_SURROGATES", + "kind": "property", + "documentation": "HIGH_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "HIGH_SURROGATES" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeBlock", + "insertText": "HIRAGANA" + }, + { + "label": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", + "kind": "property", + "documentation": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS: java.lang.Character$UnicodeBlock", + "insertText": "IDEOGRAPHIC_DESCRIPTION_CHARACTERS" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeBlock", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeBlock", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "IPA_EXTENSIONS", + "kind": "property", + "documentation": "IPA_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "IPA_EXTENSIONS" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeBlock", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeBlock", + "insertText": "KAITHI" + }, + { + "label": "KANA_SUPPLEMENT", + "kind": "property", + "documentation": "KANA_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "KANA_SUPPLEMENT" + }, + { + "label": "KANBUN", + "kind": "property", + "documentation": "KANBUN: java.lang.Character$UnicodeBlock", + "insertText": "KANBUN" + }, + { + "label": "KANGXI_RADICALS", + "kind": "property", + "documentation": "KANGXI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "KANGXI_RADICALS" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeBlock", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA" + }, + { + "label": "KATAKANA_PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "KATAKANA_PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "KATAKANA_PHONETIC_EXTENSIONS" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeBlock", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeBlock", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeBlock", + "insertText": "KHMER" + }, + { + "label": "KHMER_SYMBOLS", + "kind": "property", + "documentation": "KHMER_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "KHMER_SYMBOLS" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeBlock", + "insertText": "LAO" + }, + { + "label": "LATIN_1_SUPPLEMENT", + "kind": "property", + "documentation": "LATIN_1_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_1_SUPPLEMENT" + }, + { + "label": "LATIN_EXTENDED_A", + "kind": "property", + "documentation": "LATIN_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_A" + }, + { + "label": "LATIN_EXTENDED_ADDITIONAL", + "kind": "property", + "documentation": "LATIN_EXTENDED_ADDITIONAL: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_ADDITIONAL" + }, + { + "label": "LATIN_EXTENDED_B", + "kind": "property", + "documentation": "LATIN_EXTENDED_B: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_B" + }, + { + "label": "LATIN_EXTENDED_C", + "kind": "property", + "documentation": "LATIN_EXTENDED_C: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_C" + }, + { + "label": "LATIN_EXTENDED_D", + "kind": "property", + "documentation": "LATIN_EXTENDED_D: java.lang.Character$UnicodeBlock", + "insertText": "LATIN_EXTENDED_D" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeBlock", + "insertText": "LEPCHA" + }, + { + "label": "LETTERLIKE_SYMBOLS", + "kind": "property", + "documentation": "LETTERLIKE_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "LETTERLIKE_SYMBOLS" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeBlock", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B_IDEOGRAMS", + "kind": "property", + "documentation": "LINEAR_B_IDEOGRAMS: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_IDEOGRAMS" + }, + { + "label": "LINEAR_B_SYLLABARY", + "kind": "property", + "documentation": "LINEAR_B_SYLLABARY: java.lang.Character$UnicodeBlock", + "insertText": "LINEAR_B_SYLLABARY" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeBlock", + "insertText": "LISU" + }, + { + "label": "LOW_SURROGATES", + "kind": "property", + "documentation": "LOW_SURROGATES: java.lang.Character$UnicodeBlock", + "insertText": "LOW_SURROGATES" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeBlock", + "insertText": "LYDIAN" + }, + { + "label": "MAHJONG_TILES", + "kind": "property", + "documentation": "MAHJONG_TILES: java.lang.Character$UnicodeBlock", + "insertText": "MAHJONG_TILES" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeBlock", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeBlock", + "insertText": "MANDAIC" + }, + { + "label": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", + "kind": "property", + "documentation": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_ALPHANUMERIC_SYMBOLS" + }, + { + "label": "MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "MATHEMATICAL_OPERATORS" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEETEI_MAYEK_EXTENSIONS", + "kind": "property", + "documentation": "MEETEI_MAYEK_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "MEETEI_MAYEK_EXTENSIONS" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeBlock", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeBlock", + "insertText": "MIAO" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A" + }, + { + "label": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", + "kind": "property", + "documentation": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B" + }, + { + "label": "MISCELLANEOUS_SYMBOLS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_ARROWS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_ARROWS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_ARROWS" + }, + { + "label": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", + "kind": "property", + "documentation": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS" + }, + { + "label": "MISCELLANEOUS_TECHNICAL", + "kind": "property", + "documentation": "MISCELLANEOUS_TECHNICAL: java.lang.Character$UnicodeBlock", + "insertText": "MISCELLANEOUS_TECHNICAL" + }, + { + "label": "MODIFIER_TONE_LETTERS", + "kind": "property", + "documentation": "MODIFIER_TONE_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "MODIFIER_TONE_LETTERS" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeBlock", + "insertText": "MONGOLIAN" + }, + { + "label": "MUSICAL_SYMBOLS", + "kind": "property", + "documentation": "MUSICAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "MUSICAL_SYMBOLS" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR" + }, + { + "label": "MYANMAR_EXTENDED_A", + "kind": "property", + "documentation": "MYANMAR_EXTENDED_A: java.lang.Character$UnicodeBlock", + "insertText": "MYANMAR_EXTENDED_A" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeBlock", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeBlock", + "insertText": "NKO" + }, + { + "label": "NUMBER_FORMS", + "kind": "property", + "documentation": "NUMBER_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "NUMBER_FORMS" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeBlock", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeBlock", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeBlock", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeBlock", + "insertText": "OL_CHIKI" + }, + { + "label": "OPTICAL_CHARACTER_RECOGNITION", + "kind": "property", + "documentation": "OPTICAL_CHARACTER_RECOGNITION: java.lang.Character$UnicodeBlock", + "insertText": "OPTICAL_CHARACTER_RECOGNITION" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeBlock", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeBlock", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeBlock", + "insertText": "PHAGS_PA" + }, + { + "label": "PHAISTOS_DISC", + "kind": "property", + "documentation": "PHAISTOS_DISC: java.lang.Character$UnicodeBlock", + "insertText": "PHAISTOS_DISC" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeBlock", + "insertText": "PHOENICIAN" + }, + { + "label": "PHONETIC_EXTENSIONS", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS" + }, + { + "label": "PHONETIC_EXTENSIONS_SUPPLEMENT", + "kind": "property", + "documentation": "PHONETIC_EXTENSIONS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "PHONETIC_EXTENSIONS_SUPPLEMENT" + }, + { + "label": "PLAYING_CARDS", + "kind": "property", + "documentation": "PLAYING_CARDS: java.lang.Character$UnicodeBlock", + "insertText": "PLAYING_CARDS" + }, + { + "label": "PRIVATE_USE_AREA", + "kind": "property", + "documentation": "PRIVATE_USE_AREA: java.lang.Character$UnicodeBlock", + "insertText": "PRIVATE_USE_AREA" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeBlock", + "insertText": "REJANG" + }, + { + "label": "RUMI_NUMERAL_SYMBOLS", + "kind": "property", + "documentation": "RUMI_NUMERAL_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "RUMI_NUMERAL_SYMBOLS" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeBlock", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeBlock", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeBlock", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeBlock", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeBlock", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeBlock", + "insertText": "SINHALA" + }, + { + "label": "SMALL_FORM_VARIANTS", + "kind": "property", + "documentation": "SMALL_FORM_VARIANTS: java.lang.Character$UnicodeBlock", + "insertText": "SMALL_FORM_VARIANTS" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeBlock", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SPACING_MODIFIER_LETTERS", + "kind": "property", + "documentation": "SPACING_MODIFIER_LETTERS: java.lang.Character$UnicodeBlock", + "insertText": "SPACING_MODIFIER_LETTERS" + }, + { + "label": "SPECIALS", + "kind": "property", + "documentation": "SPECIALS: java.lang.Character$UnicodeBlock", + "insertText": "SPECIALS" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE" + }, + { + "label": "SUNDANESE_SUPPLEMENT", + "kind": "property", + "documentation": "SUNDANESE_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "SUNDANESE_SUPPLEMENT" + }, + { + "label": "SUPERSCRIPTS_AND_SUBSCRIPTS", + "kind": "property", + "documentation": "SUPERSCRIPTS_AND_SUBSCRIPTS: java.lang.Character$UnicodeBlock", + "insertText": "SUPERSCRIPTS_AND_SUBSCRIPTS" + }, + { + "label": "SUPPLEMENTAL_ARROWS_A", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_A" + }, + { + "label": "SUPPLEMENTAL_ARROWS_B", + "kind": "property", + "documentation": "SUPPLEMENTAL_ARROWS_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_ARROWS_B" + }, + { + "label": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", + "kind": "property", + "documentation": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_MATHEMATICAL_OPERATORS" + }, + { + "label": "SUPPLEMENTAL_PUNCTUATION", + "kind": "property", + "documentation": "SUPPLEMENTAL_PUNCTUATION: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTAL_PUNCTUATION" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_A", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_A: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_A" + }, + { + "label": "SUPPLEMENTARY_PRIVATE_USE_AREA_B", + "kind": "property", + "documentation": "SUPPLEMENTARY_PRIVATE_USE_AREA_B: java.lang.Character$UnicodeBlock", + "insertText": "SUPPLEMENTARY_PRIVATE_USE_AREA_B" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeBlock", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeBlock", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeBlock", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeBlock", + "insertText": "TAGBANWA" + }, + { + "label": "TAGS", + "kind": "property", + "documentation": "TAGS: java.lang.Character$UnicodeBlock", + "insertText": "TAGS" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeBlock", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeBlock", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeBlock", + "insertText": "TAI_VIET" + }, + { + "label": "TAI_XUAN_JING_SYMBOLS", + "kind": "property", + "documentation": "TAI_XUAN_JING_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TAI_XUAN_JING_SYMBOLS" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeBlock", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeBlock", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeBlock", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeBlock", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeBlock", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeBlock", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeBlock", + "insertText": "TIFINAGH" + }, + { + "label": "TRANSPORT_AND_MAP_SYMBOLS", + "kind": "property", + "documentation": "TRANSPORT_AND_MAP_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "TRANSPORT_AND_MAP_SYMBOLS" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeBlock", + "insertText": "UGARITIC" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS" + }, + { + "label": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", + "kind": "property", + "documentation": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: java.lang.Character$UnicodeBlock", + "insertText": "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeBlock", + "insertText": "VAI" + }, + { + "label": "VARIATION_SELECTORS", + "kind": "property", + "documentation": "VARIATION_SELECTORS: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS" + }, + { + "label": "VARIATION_SELECTORS_SUPPLEMENT", + "kind": "property", + "documentation": "VARIATION_SELECTORS_SUPPLEMENT: java.lang.Character$UnicodeBlock", + "insertText": "VARIATION_SELECTORS_SUPPLEMENT" + }, + { + "label": "VEDIC_EXTENSIONS", + "kind": "property", + "documentation": "VEDIC_EXTENSIONS: java.lang.Character$UnicodeBlock", + "insertText": "VEDIC_EXTENSIONS" + }, + { + "label": "VERTICAL_FORMS", + "kind": "property", + "documentation": "VERTICAL_FORMS: java.lang.Character$UnicodeBlock", + "insertText": "VERTICAL_FORMS" + }, + { + "label": "YIJING_HEXAGRAM_SYMBOLS", + "kind": "property", + "documentation": "YIJING_HEXAGRAM_SYMBOLS: java.lang.Character$UnicodeBlock", + "insertText": "YIJING_HEXAGRAM_SYMBOLS" + }, + { + "label": "YI_RADICALS", + "kind": "property", + "documentation": "YI_RADICALS: java.lang.Character$UnicodeBlock", + "insertText": "YI_RADICALS" + }, + { + "label": "YI_SYLLABLES", + "kind": "property", + "documentation": "YI_SYLLABLES: java.lang.Character$UnicodeBlock", + "insertText": "YI_SYLLABLES" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeBlock", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeBlock", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Character.UnicodeScript", + "kind": "class", + "documentation": "Class: Character.UnicodeScript", + "insertText": "Character.UnicodeScript", + "properties": [ + { + "label": "ARABIC", + "kind": "property", + "documentation": "ARABIC: java.lang.Character$UnicodeScript", + "insertText": "ARABIC" + }, + { + "label": "ARMENIAN", + "kind": "property", + "documentation": "ARMENIAN: java.lang.Character$UnicodeScript", + "insertText": "ARMENIAN" + }, + { + "label": "AVESTAN", + "kind": "property", + "documentation": "AVESTAN: java.lang.Character$UnicodeScript", + "insertText": "AVESTAN" + }, + { + "label": "BALINESE", + "kind": "property", + "documentation": "BALINESE: java.lang.Character$UnicodeScript", + "insertText": "BALINESE" + }, + { + "label": "BAMUM", + "kind": "property", + "documentation": "BAMUM: java.lang.Character$UnicodeScript", + "insertText": "BAMUM" + }, + { + "label": "BATAK", + "kind": "property", + "documentation": "BATAK: java.lang.Character$UnicodeScript", + "insertText": "BATAK" + }, + { + "label": "BENGALI", + "kind": "property", + "documentation": "BENGALI: java.lang.Character$UnicodeScript", + "insertText": "BENGALI" + }, + { + "label": "BOPOMOFO", + "kind": "property", + "documentation": "BOPOMOFO: java.lang.Character$UnicodeScript", + "insertText": "BOPOMOFO" + }, + { + "label": "BRAHMI", + "kind": "property", + "documentation": "BRAHMI: java.lang.Character$UnicodeScript", + "insertText": "BRAHMI" + }, + { + "label": "BRAILLE", + "kind": "property", + "documentation": "BRAILLE: java.lang.Character$UnicodeScript", + "insertText": "BRAILLE" + }, + { + "label": "BUGINESE", + "kind": "property", + "documentation": "BUGINESE: java.lang.Character$UnicodeScript", + "insertText": "BUGINESE" + }, + { + "label": "BUHID", + "kind": "property", + "documentation": "BUHID: java.lang.Character$UnicodeScript", + "insertText": "BUHID" + }, + { + "label": "CANADIAN_ABORIGINAL", + "kind": "property", + "documentation": "CANADIAN_ABORIGINAL: java.lang.Character$UnicodeScript", + "insertText": "CANADIAN_ABORIGINAL" + }, + { + "label": "CARIAN", + "kind": "property", + "documentation": "CARIAN: java.lang.Character$UnicodeScript", + "insertText": "CARIAN" + }, + { + "label": "CHAKMA", + "kind": "property", + "documentation": "CHAKMA: java.lang.Character$UnicodeScript", + "insertText": "CHAKMA" + }, + { + "label": "CHAM", + "kind": "property", + "documentation": "CHAM: java.lang.Character$UnicodeScript", + "insertText": "CHAM" + }, + { + "label": "CHEROKEE", + "kind": "property", + "documentation": "CHEROKEE: java.lang.Character$UnicodeScript", + "insertText": "CHEROKEE" + }, + { + "label": "COMMON", + "kind": "property", + "documentation": "COMMON: java.lang.Character$UnicodeScript", + "insertText": "COMMON" + }, + { + "label": "COPTIC", + "kind": "property", + "documentation": "COPTIC: java.lang.Character$UnicodeScript", + "insertText": "COPTIC" + }, + { + "label": "CUNEIFORM", + "kind": "property", + "documentation": "CUNEIFORM: java.lang.Character$UnicodeScript", + "insertText": "CUNEIFORM" + }, + { + "label": "CYPRIOT", + "kind": "property", + "documentation": "CYPRIOT: java.lang.Character$UnicodeScript", + "insertText": "CYPRIOT" + }, + { + "label": "CYRILLIC", + "kind": "property", + "documentation": "CYRILLIC: java.lang.Character$UnicodeScript", + "insertText": "CYRILLIC" + }, + { + "label": "DESERET", + "kind": "property", + "documentation": "DESERET: java.lang.Character$UnicodeScript", + "insertText": "DESERET" + }, + { + "label": "DEVANAGARI", + "kind": "property", + "documentation": "DEVANAGARI: java.lang.Character$UnicodeScript", + "insertText": "DEVANAGARI" + }, + { + "label": "EGYPTIAN_HIEROGLYPHS", + "kind": "property", + "documentation": "EGYPTIAN_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "EGYPTIAN_HIEROGLYPHS" + }, + { + "label": "ETHIOPIC", + "kind": "property", + "documentation": "ETHIOPIC: java.lang.Character$UnicodeScript", + "insertText": "ETHIOPIC" + }, + { + "label": "GEORGIAN", + "kind": "property", + "documentation": "GEORGIAN: java.lang.Character$UnicodeScript", + "insertText": "GEORGIAN" + }, + { + "label": "GLAGOLITIC", + "kind": "property", + "documentation": "GLAGOLITIC: java.lang.Character$UnicodeScript", + "insertText": "GLAGOLITIC" + }, + { + "label": "GOTHIC", + "kind": "property", + "documentation": "GOTHIC: java.lang.Character$UnicodeScript", + "insertText": "GOTHIC" + }, + { + "label": "GREEK", + "kind": "property", + "documentation": "GREEK: java.lang.Character$UnicodeScript", + "insertText": "GREEK" + }, + { + "label": "GUJARATI", + "kind": "property", + "documentation": "GUJARATI: java.lang.Character$UnicodeScript", + "insertText": "GUJARATI" + }, + { + "label": "GURMUKHI", + "kind": "property", + "documentation": "GURMUKHI: java.lang.Character$UnicodeScript", + "insertText": "GURMUKHI" + }, + { + "label": "HAN", + "kind": "property", + "documentation": "HAN: java.lang.Character$UnicodeScript", + "insertText": "HAN" + }, + { + "label": "HANGUL", + "kind": "property", + "documentation": "HANGUL: java.lang.Character$UnicodeScript", + "insertText": "HANGUL" + }, + { + "label": "HANUNOO", + "kind": "property", + "documentation": "HANUNOO: java.lang.Character$UnicodeScript", + "insertText": "HANUNOO" + }, + { + "label": "HEBREW", + "kind": "property", + "documentation": "HEBREW: java.lang.Character$UnicodeScript", + "insertText": "HEBREW" + }, + { + "label": "HIRAGANA", + "kind": "property", + "documentation": "HIRAGANA: java.lang.Character$UnicodeScript", + "insertText": "HIRAGANA" + }, + { + "label": "IMPERIAL_ARAMAIC", + "kind": "property", + "documentation": "IMPERIAL_ARAMAIC: java.lang.Character$UnicodeScript", + "insertText": "IMPERIAL_ARAMAIC" + }, + { + "label": "INHERITED", + "kind": "property", + "documentation": "INHERITED: java.lang.Character$UnicodeScript", + "insertText": "INHERITED" + }, + { + "label": "INSCRIPTIONAL_PAHLAVI", + "kind": "property", + "documentation": "INSCRIPTIONAL_PAHLAVI: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PAHLAVI" + }, + { + "label": "INSCRIPTIONAL_PARTHIAN", + "kind": "property", + "documentation": "INSCRIPTIONAL_PARTHIAN: java.lang.Character$UnicodeScript", + "insertText": "INSCRIPTIONAL_PARTHIAN" + }, + { + "label": "JAVANESE", + "kind": "property", + "documentation": "JAVANESE: java.lang.Character$UnicodeScript", + "insertText": "JAVANESE" + }, + { + "label": "KAITHI", + "kind": "property", + "documentation": "KAITHI: java.lang.Character$UnicodeScript", + "insertText": "KAITHI" + }, + { + "label": "KANNADA", + "kind": "property", + "documentation": "KANNADA: java.lang.Character$UnicodeScript", + "insertText": "KANNADA" + }, + { + "label": "KATAKANA", + "kind": "property", + "documentation": "KATAKANA: java.lang.Character$UnicodeScript", + "insertText": "KATAKANA" + }, + { + "label": "KAYAH_LI", + "kind": "property", + "documentation": "KAYAH_LI: java.lang.Character$UnicodeScript", + "insertText": "KAYAH_LI" + }, + { + "label": "KHAROSHTHI", + "kind": "property", + "documentation": "KHAROSHTHI: java.lang.Character$UnicodeScript", + "insertText": "KHAROSHTHI" + }, + { + "label": "KHMER", + "kind": "property", + "documentation": "KHMER: java.lang.Character$UnicodeScript", + "insertText": "KHMER" + }, + { + "label": "LAO", + "kind": "property", + "documentation": "LAO: java.lang.Character$UnicodeScript", + "insertText": "LAO" + }, + { + "label": "LATIN", + "kind": "property", + "documentation": "LATIN: java.lang.Character$UnicodeScript", + "insertText": "LATIN" + }, + { + "label": "LEPCHA", + "kind": "property", + "documentation": "LEPCHA: java.lang.Character$UnicodeScript", + "insertText": "LEPCHA" + }, + { + "label": "LIMBU", + "kind": "property", + "documentation": "LIMBU: java.lang.Character$UnicodeScript", + "insertText": "LIMBU" + }, + { + "label": "LINEAR_B", + "kind": "property", + "documentation": "LINEAR_B: java.lang.Character$UnicodeScript", + "insertText": "LINEAR_B" + }, + { + "label": "LISU", + "kind": "property", + "documentation": "LISU: java.lang.Character$UnicodeScript", + "insertText": "LISU" + }, + { + "label": "LYCIAN", + "kind": "property", + "documentation": "LYCIAN: java.lang.Character$UnicodeScript", + "insertText": "LYCIAN" + }, + { + "label": "LYDIAN", + "kind": "property", + "documentation": "LYDIAN: java.lang.Character$UnicodeScript", + "insertText": "LYDIAN" + }, + { + "label": "MALAYALAM", + "kind": "property", + "documentation": "MALAYALAM: java.lang.Character$UnicodeScript", + "insertText": "MALAYALAM" + }, + { + "label": "MANDAIC", + "kind": "property", + "documentation": "MANDAIC: java.lang.Character$UnicodeScript", + "insertText": "MANDAIC" + }, + { + "label": "MEETEI_MAYEK", + "kind": "property", + "documentation": "MEETEI_MAYEK: java.lang.Character$UnicodeScript", + "insertText": "MEETEI_MAYEK" + }, + { + "label": "MEROITIC_CURSIVE", + "kind": "property", + "documentation": "MEROITIC_CURSIVE: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_CURSIVE" + }, + { + "label": "MEROITIC_HIEROGLYPHS", + "kind": "property", + "documentation": "MEROITIC_HIEROGLYPHS: java.lang.Character$UnicodeScript", + "insertText": "MEROITIC_HIEROGLYPHS" + }, + { + "label": "MIAO", + "kind": "property", + "documentation": "MIAO: java.lang.Character$UnicodeScript", + "insertText": "MIAO" + }, + { + "label": "MONGOLIAN", + "kind": "property", + "documentation": "MONGOLIAN: java.lang.Character$UnicodeScript", + "insertText": "MONGOLIAN" + }, + { + "label": "MYANMAR", + "kind": "property", + "documentation": "MYANMAR: java.lang.Character$UnicodeScript", + "insertText": "MYANMAR" + }, + { + "label": "NEW_TAI_LUE", + "kind": "property", + "documentation": "NEW_TAI_LUE: java.lang.Character$UnicodeScript", + "insertText": "NEW_TAI_LUE" + }, + { + "label": "NKO", + "kind": "property", + "documentation": "NKO: java.lang.Character$UnicodeScript", + "insertText": "NKO" + }, + { + "label": "OGHAM", + "kind": "property", + "documentation": "OGHAM: java.lang.Character$UnicodeScript", + "insertText": "OGHAM" + }, + { + "label": "OLD_ITALIC", + "kind": "property", + "documentation": "OLD_ITALIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_ITALIC" + }, + { + "label": "OLD_PERSIAN", + "kind": "property", + "documentation": "OLD_PERSIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_PERSIAN" + }, + { + "label": "OLD_SOUTH_ARABIAN", + "kind": "property", + "documentation": "OLD_SOUTH_ARABIAN: java.lang.Character$UnicodeScript", + "insertText": "OLD_SOUTH_ARABIAN" + }, + { + "label": "OLD_TURKIC", + "kind": "property", + "documentation": "OLD_TURKIC: java.lang.Character$UnicodeScript", + "insertText": "OLD_TURKIC" + }, + { + "label": "OL_CHIKI", + "kind": "property", + "documentation": "OL_CHIKI: java.lang.Character$UnicodeScript", + "insertText": "OL_CHIKI" + }, + { + "label": "ORIYA", + "kind": "property", + "documentation": "ORIYA: java.lang.Character$UnicodeScript", + "insertText": "ORIYA" + }, + { + "label": "OSMANYA", + "kind": "property", + "documentation": "OSMANYA: java.lang.Character$UnicodeScript", + "insertText": "OSMANYA" + }, + { + "label": "PHAGS_PA", + "kind": "property", + "documentation": "PHAGS_PA: java.lang.Character$UnicodeScript", + "insertText": "PHAGS_PA" + }, + { + "label": "PHOENICIAN", + "kind": "property", + "documentation": "PHOENICIAN: java.lang.Character$UnicodeScript", + "insertText": "PHOENICIAN" + }, + { + "label": "REJANG", + "kind": "property", + "documentation": "REJANG: java.lang.Character$UnicodeScript", + "insertText": "REJANG" + }, + { + "label": "RUNIC", + "kind": "property", + "documentation": "RUNIC: java.lang.Character$UnicodeScript", + "insertText": "RUNIC" + }, + { + "label": "SAMARITAN", + "kind": "property", + "documentation": "SAMARITAN: java.lang.Character$UnicodeScript", + "insertText": "SAMARITAN" + }, + { + "label": "SAURASHTRA", + "kind": "property", + "documentation": "SAURASHTRA: java.lang.Character$UnicodeScript", + "insertText": "SAURASHTRA" + }, + { + "label": "SHARADA", + "kind": "property", + "documentation": "SHARADA: java.lang.Character$UnicodeScript", + "insertText": "SHARADA" + }, + { + "label": "SHAVIAN", + "kind": "property", + "documentation": "SHAVIAN: java.lang.Character$UnicodeScript", + "insertText": "SHAVIAN" + }, + { + "label": "SINHALA", + "kind": "property", + "documentation": "SINHALA: java.lang.Character$UnicodeScript", + "insertText": "SINHALA" + }, + { + "label": "SORA_SOMPENG", + "kind": "property", + "documentation": "SORA_SOMPENG: java.lang.Character$UnicodeScript", + "insertText": "SORA_SOMPENG" + }, + { + "label": "SUNDANESE", + "kind": "property", + "documentation": "SUNDANESE: java.lang.Character$UnicodeScript", + "insertText": "SUNDANESE" + }, + { + "label": "SYLOTI_NAGRI", + "kind": "property", + "documentation": "SYLOTI_NAGRI: java.lang.Character$UnicodeScript", + "insertText": "SYLOTI_NAGRI" + }, + { + "label": "SYRIAC", + "kind": "property", + "documentation": "SYRIAC: java.lang.Character$UnicodeScript", + "insertText": "SYRIAC" + }, + { + "label": "TAGALOG", + "kind": "property", + "documentation": "TAGALOG: java.lang.Character$UnicodeScript", + "insertText": "TAGALOG" + }, + { + "label": "TAGBANWA", + "kind": "property", + "documentation": "TAGBANWA: java.lang.Character$UnicodeScript", + "insertText": "TAGBANWA" + }, + { + "label": "TAI_LE", + "kind": "property", + "documentation": "TAI_LE: java.lang.Character$UnicodeScript", + "insertText": "TAI_LE" + }, + { + "label": "TAI_THAM", + "kind": "property", + "documentation": "TAI_THAM: java.lang.Character$UnicodeScript", + "insertText": "TAI_THAM" + }, + { + "label": "TAI_VIET", + "kind": "property", + "documentation": "TAI_VIET: java.lang.Character$UnicodeScript", + "insertText": "TAI_VIET" + }, + { + "label": "TAKRI", + "kind": "property", + "documentation": "TAKRI: java.lang.Character$UnicodeScript", + "insertText": "TAKRI" + }, + { + "label": "TAMIL", + "kind": "property", + "documentation": "TAMIL: java.lang.Character$UnicodeScript", + "insertText": "TAMIL" + }, + { + "label": "TELUGU", + "kind": "property", + "documentation": "TELUGU: java.lang.Character$UnicodeScript", + "insertText": "TELUGU" + }, + { + "label": "THAANA", + "kind": "property", + "documentation": "THAANA: java.lang.Character$UnicodeScript", + "insertText": "THAANA" + }, + { + "label": "THAI", + "kind": "property", + "documentation": "THAI: java.lang.Character$UnicodeScript", + "insertText": "THAI" + }, + { + "label": "TIBETAN", + "kind": "property", + "documentation": "TIBETAN: java.lang.Character$UnicodeScript", + "insertText": "TIBETAN" + }, + { + "label": "TIFINAGH", + "kind": "property", + "documentation": "TIFINAGH: java.lang.Character$UnicodeScript", + "insertText": "TIFINAGH" + }, + { + "label": "UGARITIC", + "kind": "property", + "documentation": "UGARITIC: java.lang.Character$UnicodeScript", + "insertText": "UGARITIC" + }, + { + "label": "UNKNOWN", + "kind": "property", + "documentation": "UNKNOWN: java.lang.Character$UnicodeScript", + "insertText": "UNKNOWN" + }, + { + "label": "VAI", + "kind": "property", + "documentation": "VAI: java.lang.Character$UnicodeScript", + "insertText": "VAI" + }, + { + "label": "YI", + "kind": "property", + "documentation": "YI: java.lang.Character$UnicodeScript", + "insertText": "YI" + }, + { + "label": "forName", + "kind": "method", + "documentation": "forName(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "forName" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.lang.Character$UnicodeScript", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.lang.Character$UnicodeScript", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.lang.Character$UnicodeScript;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ClassCastException", + "kind": "class", + "documentation": "Class: ClassCastException", + "insertText": "ClassCastException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassCastException", + "kind": "constructor", + "documentation": "Constructor: ClassCastException", + "insertText": "ClassCastException" + } + }, + { + "label": "ClassNotFoundException", + "kind": "class", + "documentation": "Class: ClassNotFoundException", + "insertText": "ClassNotFoundException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ClassNotFoundException", + "kind": "constructor", + "documentation": "Constructor: ClassNotFoundException", + "insertText": "ClassNotFoundException" + } + }, + { + "label": "CloneNotSupportedException", + "kind": "class", + "documentation": "Class: CloneNotSupportedException", + "insertText": "CloneNotSupportedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "CloneNotSupportedException", + "kind": "constructor", + "documentation": "Constructor: CloneNotSupportedException", + "insertText": "CloneNotSupportedException" + } + }, + { + "label": "Comparable", + "kind": "class", + "documentation": "Class: Comparable", + "insertText": "Comparable", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Double", + "kind": "class", + "documentation": "Class: Double", + "insertText": "Double", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: double", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: double", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: double", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: double", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: double", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: double", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(double a, double b): int", + "insertText": "compare" + }, + { + "label": "doubleToLongBits", + "kind": "method", + "documentation": "doubleToLongBits(double a): long", + "insertText": "doubleToLongBits" + }, + { + "label": "doubleToRawLongBits", + "kind": "method", + "documentation": "doubleToRawLongBits(double a): long", + "insertText": "doubleToRawLongBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(double a): int", + "insertText": "hashCode" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(double a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(double a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(double a): boolean", + "insertText": "isNaN" + }, + { + "label": "longBitsToDouble", + "kind": "method", + "documentation": "longBitsToDouble(long a): double", + "insertText": "longBitsToDouble" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "parseDouble", + "kind": "method", + "documentation": "parseDouble(java.lang.String a): double", + "insertText": "parseDouble" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(double a, double b): double", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(double a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(double a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.lang.Double", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Double a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Enum", + "kind": "class", + "documentation": "Class: Enum", + "insertText": "Enum", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EnumConstantNotPresentException", + "kind": "class", + "documentation": "Class: EnumConstantNotPresentException", + "insertText": "EnumConstantNotPresentException", + "properties": [ + { + "label": "constantName", + "kind": "method", + "documentation": "constantName(): java.lang.String", + "insertText": "constantName" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Exception", + "kind": "class", + "documentation": "Class: Exception", + "insertText": "Exception", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Exception", + "kind": "constructor", + "documentation": "Constructor: Exception", + "insertText": "Exception" + } + }, + { + "label": "Float", + "kind": "class", + "documentation": "Class: Float", + "insertText": "Float", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_EXPONENT", + "kind": "property", + "documentation": "MAX_EXPONENT: int", + "insertText": "MAX_EXPONENT" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: float", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_EXPONENT", + "kind": "property", + "documentation": "MIN_EXPONENT: int", + "insertText": "MIN_EXPONENT" + }, + { + "label": "MIN_NORMAL", + "kind": "property", + "documentation": "MIN_NORMAL: float", + "insertText": "MIN_NORMAL" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: float", + "insertText": "MIN_VALUE" + }, + { + "label": "NEGATIVE_INFINITY", + "kind": "property", + "documentation": "NEGATIVE_INFINITY: float", + "insertText": "NEGATIVE_INFINITY" + }, + { + "label": "NaN", + "kind": "property", + "documentation": "NaN: float", + "insertText": "NaN" + }, + { + "label": "POSITIVE_INFINITY", + "kind": "property", + "documentation": "POSITIVE_INFINITY: float", + "insertText": "POSITIVE_INFINITY" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(float a, float b): int", + "insertText": "compare" + }, + { + "label": "floatToIntBits", + "kind": "method", + "documentation": "floatToIntBits(float a): int", + "insertText": "floatToIntBits" + }, + { + "label": "floatToRawIntBits", + "kind": "method", + "documentation": "floatToRawIntBits(float a): int", + "insertText": "floatToRawIntBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(float a): int", + "insertText": "hashCode" + }, + { + "label": "intBitsToFloat", + "kind": "method", + "documentation": "intBitsToFloat(int a): float", + "insertText": "intBitsToFloat" + }, + { + "label": "isFinite", + "kind": "method", + "documentation": "isFinite(float a): boolean", + "insertText": "isFinite" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(float a): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(float a): boolean", + "insertText": "isNaN" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(float a, float b): float", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(float a, float b): float", + "insertText": "min" + }, + { + "label": "parseFloat", + "kind": "method", + "documentation": "parseFloat(java.lang.String a): float", + "insertText": "parseFloat" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(float a, float b): float", + "insertText": "sum" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(float a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(float a): java.lang.String", + "insertText": "toString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(float a): java.lang.Float", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Float a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "isInfinite", + "kind": "method", + "documentation": "isInfinite(): boolean", + "insertText": "isInfinite" + }, + { + "label": "isNaN", + "kind": "method", + "documentation": "isNaN(): boolean", + "insertText": "isNaN" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalAccessException", + "kind": "class", + "documentation": "Class: IllegalAccessException", + "insertText": "IllegalAccessException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalAccessException", + "kind": "constructor", + "documentation": "Constructor: IllegalAccessException", + "insertText": "IllegalAccessException" + } + }, + { + "label": "IllegalArgumentException", + "kind": "class", + "documentation": "Class: IllegalArgumentException", + "insertText": "IllegalArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalArgumentException", + "kind": "constructor", + "documentation": "Constructor: IllegalArgumentException", + "insertText": "IllegalArgumentException" + } + }, + { + "label": "IllegalMonitorStateException", + "kind": "class", + "documentation": "Class: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalMonitorStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalMonitorStateException", + "insertText": "IllegalMonitorStateException" + } + }, + { + "label": "IllegalStateException", + "kind": "class", + "documentation": "Class: IllegalStateException", + "insertText": "IllegalStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalStateException", + "insertText": "IllegalStateException" + } + }, + { + "label": "IllegalThreadStateException", + "kind": "class", + "documentation": "Class: IllegalThreadStateException", + "insertText": "IllegalThreadStateException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalThreadStateException", + "kind": "constructor", + "documentation": "Constructor: IllegalThreadStateException", + "insertText": "IllegalThreadStateException" + } + }, + { + "label": "IndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: IndexOutOfBoundsException", + "insertText": "IndexOutOfBoundsException" + } + }, + { + "label": "InstantiationException", + "kind": "class", + "documentation": "Class: InstantiationException", + "insertText": "InstantiationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InstantiationException", + "kind": "constructor", + "documentation": "Constructor: InstantiationException", + "insertText": "InstantiationException" + } + }, + { + "label": "Integer", + "kind": "class", + "documentation": "Class: Integer", + "insertText": "Integer", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(int a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(int a, int b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(int a, int b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Integer", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(int a, int b): int", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(int a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(int a): int", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(int a): int", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(int a, int b): int", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(int a, int b): int", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(int a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(int a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseInt", + "kind": "method", + "documentation": "parseInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseInt" + }, + { + "label": "parseUnsignedInt", + "kind": "method", + "documentation": "parseUnsignedInt(java.lang.String a, int b | java.lang.String a): int", + "insertText": "parseUnsignedInt" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(int a, int b): int", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(int a): int", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(int a): int", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(int a, int b): int", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(int a, int b): int", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(int a): int", + "insertText": "signum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(int a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(int a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(int a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a, int b | int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(int a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(int a, int b | int a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | int a): java.lang.Integer", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Integer a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "InterruptedException", + "kind": "class", + "documentation": "Class: InterruptedException", + "insertText": "InterruptedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InterruptedException", + "kind": "constructor", + "documentation": "Constructor: InterruptedException", + "insertText": "InterruptedException" + } + }, + { + "label": "Iterable", + "kind": "class", + "documentation": "Class: Iterable", + "insertText": "Iterable", + "properties": [ + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Long", + "kind": "class", + "documentation": "Class: Long", + "insertText": "Long", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: long", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: long", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(long a): int", + "insertText": "bitCount" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(long a, long b): int", + "insertText": "compare" + }, + { + "label": "compareUnsigned", + "kind": "method", + "documentation": "compareUnsigned(long a, long b): int", + "insertText": "compareUnsigned" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Long", + "insertText": "decode" + }, + { + "label": "divideUnsigned", + "kind": "method", + "documentation": "divideUnsigned(long a, long b): long", + "insertText": "divideUnsigned" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(long a): int", + "insertText": "hashCode" + }, + { + "label": "highestOneBit", + "kind": "method", + "documentation": "highestOneBit(long a): long", + "insertText": "highestOneBit" + }, + { + "label": "lowestOneBit", + "kind": "method", + "documentation": "lowestOneBit(long a): long", + "insertText": "lowestOneBit" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(long a, long b): long", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(long a, long b): long", + "insertText": "min" + }, + { + "label": "numberOfLeadingZeros", + "kind": "method", + "documentation": "numberOfLeadingZeros(long a): int", + "insertText": "numberOfLeadingZeros" + }, + { + "label": "numberOfTrailingZeros", + "kind": "method", + "documentation": "numberOfTrailingZeros(long a): int", + "insertText": "numberOfTrailingZeros" + }, + { + "label": "parseLong", + "kind": "method", + "documentation": "parseLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseLong" + }, + { + "label": "parseUnsignedLong", + "kind": "method", + "documentation": "parseUnsignedLong(java.lang.String a, int b | java.lang.String a): long", + "insertText": "parseUnsignedLong" + }, + { + "label": "remainderUnsigned", + "kind": "method", + "documentation": "remainderUnsigned(long a, long b): long", + "insertText": "remainderUnsigned" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(long a): long", + "insertText": "reverse" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(long a): long", + "insertText": "reverseBytes" + }, + { + "label": "rotateLeft", + "kind": "method", + "documentation": "rotateLeft(long a, int b): long", + "insertText": "rotateLeft" + }, + { + "label": "rotateRight", + "kind": "method", + "documentation": "rotateRight(long a, int b): long", + "insertText": "rotateRight" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(long a): int", + "insertText": "signum" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(long a, long b): long", + "insertText": "sum" + }, + { + "label": "toBinaryString", + "kind": "method", + "documentation": "toBinaryString(long a): java.lang.String", + "insertText": "toBinaryString" + }, + { + "label": "toHexString", + "kind": "method", + "documentation": "toHexString(long a): java.lang.String", + "insertText": "toHexString" + }, + { + "label": "toOctalString", + "kind": "method", + "documentation": "toOctalString(long a): java.lang.String", + "insertText": "toOctalString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(long a, int b | long a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedString", + "kind": "method", + "documentation": "toUnsignedString(long a, int b | long a): java.lang.String", + "insertText": "toUnsignedString" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | long a): java.lang.Long", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Long a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Math", + "kind": "class", + "documentation": "Class: Math", + "insertText": "Math", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NegativeArraySizeException", + "kind": "class", + "documentation": "Class: NegativeArraySizeException", + "insertText": "NegativeArraySizeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NegativeArraySizeException", + "kind": "constructor", + "documentation": "Constructor: NegativeArraySizeException", + "insertText": "NegativeArraySizeException" + } + }, + { + "label": "NoSuchFieldException", + "kind": "class", + "documentation": "Class: NoSuchFieldException", + "insertText": "NoSuchFieldException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchFieldException", + "kind": "constructor", + "documentation": "Constructor: NoSuchFieldException", + "insertText": "NoSuchFieldException" + } + }, + { + "label": "NoSuchMethodException", + "kind": "class", + "documentation": "Class: NoSuchMethodException", + "insertText": "NoSuchMethodException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchMethodException", + "kind": "constructor", + "documentation": "Constructor: NoSuchMethodException", + "insertText": "NoSuchMethodException" + } + }, + { + "label": "NullPointerException", + "kind": "class", + "documentation": "Class: NullPointerException", + "insertText": "NullPointerException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NullPointerException", + "kind": "constructor", + "documentation": "Constructor: NullPointerException", + "insertText": "NullPointerException" + } + }, + { + "label": "Number", + "kind": "class", + "documentation": "Class: Number", + "insertText": "Number", + "properties": [ + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormatException", + "kind": "class", + "documentation": "Class: NumberFormatException", + "insertText": "NumberFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NumberFormatException", + "kind": "constructor", + "documentation": "Constructor: NumberFormatException", + "insertText": "NumberFormatException" + } + }, + { + "label": "Object", + "kind": "class", + "documentation": "Class: Object", + "insertText": "Object", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ReflectiveOperationException", + "kind": "class", + "documentation": "Class: ReflectiveOperationException", + "insertText": "ReflectiveOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ReflectiveOperationException", + "kind": "constructor", + "documentation": "Constructor: ReflectiveOperationException", + "insertText": "ReflectiveOperationException" + } + }, + { + "label": "RuntimeException", + "kind": "class", + "documentation": "Class: RuntimeException", + "insertText": "RuntimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuntimeException", + "kind": "constructor", + "documentation": "Constructor: RuntimeException", + "insertText": "RuntimeException" + } + }, + { + "label": "SecurityException", + "kind": "class", + "documentation": "Class: SecurityException", + "insertText": "SecurityException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SecurityException", + "kind": "constructor", + "documentation": "Constructor: SecurityException", + "insertText": "SecurityException" + } + }, + { + "label": "Short", + "kind": "class", + "documentation": "Class: Short", + "insertText": "Short", + "properties": [ + { + "label": "BYTES", + "kind": "property", + "documentation": "BYTES: int", + "insertText": "BYTES" + }, + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: short", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: short", + "insertText": "MIN_VALUE" + }, + { + "label": "SIZE", + "kind": "property", + "documentation": "SIZE: int", + "insertText": "SIZE" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(short a, short b): int", + "insertText": "compare" + }, + { + "label": "decode", + "kind": "method", + "documentation": "decode(java.lang.String a): java.lang.Short", + "insertText": "decode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(short a): int", + "insertText": "hashCode" + }, + { + "label": "parseShort", + "kind": "method", + "documentation": "parseShort(java.lang.String a, int b | java.lang.String a): short", + "insertText": "parseShort" + }, + { + "label": "reverseBytes", + "kind": "method", + "documentation": "reverseBytes(short a): short", + "insertText": "reverseBytes" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(short a): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUnsignedInt", + "kind": "method", + "documentation": "toUnsignedInt(short a): int", + "insertText": "toUnsignedInt" + }, + { + "label": "toUnsignedLong", + "kind": "method", + "documentation": "toUnsignedLong(short a): long", + "insertText": "toUnsignedLong" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a, int b | short a): java.lang.Short", + "insertText": "valueOf" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Short a): int", + "insertText": "compareTo" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "StackTraceElement", + "kind": "class", + "documentation": "Class: StackTraceElement", + "insertText": "StackTraceElement", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getFileName", + "kind": "method", + "documentation": "getFileName(): java.lang.String", + "insertText": "getFileName" + }, + { + "label": "getLineNumber", + "kind": "method", + "documentation": "getLineNumber(): int", + "insertText": "getLineNumber" + }, + { + "label": "getMethodName", + "kind": "method", + "documentation": "getMethodName(): java.lang.String", + "insertText": "getMethodName" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNativeMethod", + "kind": "method", + "documentation": "isNativeMethod(): boolean", + "insertText": "isNativeMethod" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StackTraceElement", + "kind": "constructor", + "documentation": "Constructor: StackTraceElement", + "insertText": "StackTraceElement" + } + }, + { + "label": "StrictMath", + "kind": "class", + "documentation": "Class: StrictMath", + "insertText": "StrictMath", + "properties": [ + { + "label": "E", + "kind": "property", + "documentation": "E: double", + "insertText": "E" + }, + { + "label": "PI", + "kind": "property", + "documentation": "PI: double", + "insertText": "PI" + }, + { + "label": "IEEEremainder", + "kind": "method", + "documentation": "IEEEremainder(double a, double b): double", + "insertText": "IEEEremainder" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(double a): double", + "insertText": "abs" + }, + { + "label": "acos", + "kind": "method", + "documentation": "acos(double a): double", + "insertText": "acos" + }, + { + "label": "asin", + "kind": "method", + "documentation": "asin(double a): double", + "insertText": "asin" + }, + { + "label": "atan", + "kind": "method", + "documentation": "atan(double a): double", + "insertText": "atan" + }, + { + "label": "atan2", + "kind": "method", + "documentation": "atan2(double a, double b): double", + "insertText": "atan2" + }, + { + "label": "cbrt", + "kind": "method", + "documentation": "cbrt(double a): double", + "insertText": "cbrt" + }, + { + "label": "ceil", + "kind": "method", + "documentation": "ceil(double a): double", + "insertText": "ceil" + }, + { + "label": "copySign", + "kind": "method", + "documentation": "copySign(double a, double b): double", + "insertText": "copySign" + }, + { + "label": "cos", + "kind": "method", + "documentation": "cos(double a): double", + "insertText": "cos" + }, + { + "label": "cosh", + "kind": "method", + "documentation": "cosh(double a): double", + "insertText": "cosh" + }, + { + "label": "exp", + "kind": "method", + "documentation": "exp(double a): double", + "insertText": "exp" + }, + { + "label": "expm1", + "kind": "method", + "documentation": "expm1(double a): double", + "insertText": "expm1" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(double a): double", + "insertText": "floor" + }, + { + "label": "hypot", + "kind": "method", + "documentation": "hypot(double a, double b): double", + "insertText": "hypot" + }, + { + "label": "log", + "kind": "method", + "documentation": "log(double a): double", + "insertText": "log" + }, + { + "label": "log10", + "kind": "method", + "documentation": "log10(double a): double", + "insertText": "log10" + }, + { + "label": "log1p", + "kind": "method", + "documentation": "log1p(double a): double", + "insertText": "log1p" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(double a, double b): double", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(double a, double b): double", + "insertText": "min" + }, + { + "label": "nextAfter", + "kind": "method", + "documentation": "nextAfter(double a, double b): double", + "insertText": "nextAfter" + }, + { + "label": "nextDown", + "kind": "method", + "documentation": "nextDown(double a): double", + "insertText": "nextDown" + }, + { + "label": "nextUp", + "kind": "method", + "documentation": "nextUp(double a): double", + "insertText": "nextUp" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(double a, double b): double", + "insertText": "pow" + }, + { + "label": "random", + "kind": "method", + "documentation": "random(): double", + "insertText": "random" + }, + { + "label": "rint", + "kind": "method", + "documentation": "rint(double a): double", + "insertText": "rint" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(double a): long", + "insertText": "round" + }, + { + "label": "scalb", + "kind": "method", + "documentation": "scalb(double a, int b): double", + "insertText": "scalb" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(double a): double", + "insertText": "signum" + }, + { + "label": "sin", + "kind": "method", + "documentation": "sin(double a): double", + "insertText": "sin" + }, + { + "label": "sinh", + "kind": "method", + "documentation": "sinh(double a): double", + "insertText": "sinh" + }, + { + "label": "sqrt", + "kind": "method", + "documentation": "sqrt(double a): double", + "insertText": "sqrt" + }, + { + "label": "tan", + "kind": "method", + "documentation": "tan(double a): double", + "insertText": "tan" + }, + { + "label": "tanh", + "kind": "method", + "documentation": "tanh(double a): double", + "insertText": "tanh" + }, + { + "label": "toDegrees", + "kind": "method", + "documentation": "toDegrees(double a): double", + "insertText": "toDegrees" + }, + { + "label": "toRadians", + "kind": "method", + "documentation": "toRadians(double a): double", + "insertText": "toRadians" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(double a): double", + "insertText": "ulp" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "String", + "kind": "class", + "documentation": "Class: String", + "insertText": "String", + "properties": [ + { + "label": "copyValueOf", + "kind": "method", + "documentation": "copyValueOf([C a, int b, int c | [C a): java.lang.String", + "insertText": "copyValueOf" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.lang.String", + "insertText": "format" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.CharSequence a, java.lang.Iterable b): java.lang.String", + "insertText": "join" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(org.elasticsearch.painless.lookup.def a): java.lang.String", + "insertText": "valueOf" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.String a): int", + "insertText": "compareTo" + }, + { + "label": "compareToIgnoreCase", + "kind": "method", + "documentation": "compareToIgnoreCase(java.lang.String a): int", + "insertText": "compareToIgnoreCase" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.lang.String a): java.lang.String", + "insertText": "concat" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(java.lang.CharSequence a): boolean", + "insertText": "contains" + }, + { + "label": "contentEquals", + "kind": "method", + "documentation": "contentEquals(java.lang.CharSequence a): boolean", + "insertText": "contentEquals" + }, + { + "label": "decodeBase64", + "kind": "method", + "documentation": "decodeBase64(): java.lang.String", + "insertText": "decodeBase64" + }, + { + "label": "encodeBase64", + "kind": "method", + "documentation": "encodeBase64(): java.lang.String", + "insertText": "encodeBase64" + }, + { + "label": "endsWith", + "kind": "method", + "documentation": "endsWith(java.lang.String a): boolean", + "insertText": "endsWith" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "equalsIgnoreCase", + "kind": "method", + "documentation": "equalsIgnoreCase(java.lang.String a): boolean", + "insertText": "equalsIgnoreCase" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "regionMatches", + "kind": "method", + "documentation": "regionMatches(boolean a, int b, java.lang.String c, int d, int e | int a, java.lang.String b, int c, int d): boolean", + "insertText": "regionMatches" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(java.lang.CharSequence a, java.lang.CharSequence b): java.lang.String", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "splitOnToken", + "kind": "method", + "documentation": "splitOnToken(java.lang.String a, int b | java.lang.String a): [Ljava.lang.String;", + "insertText": "splitOnToken" + }, + { + "label": "startsWith", + "kind": "method", + "documentation": "startsWith(java.lang.String a, int b | java.lang.String a): boolean", + "insertText": "startsWith" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toCharArray", + "kind": "method", + "documentation": "toCharArray(): [C", + "insertText": "toCharArray" + }, + { + "label": "toLowerCase", + "kind": "method", + "documentation": "toLowerCase(java.util.Locale a): java.lang.String", + "insertText": "toLowerCase" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toUpperCase", + "kind": "method", + "documentation": "toUpperCase(java.util.Locale a): java.lang.String", + "insertText": "toUpperCase" + }, + { + "label": "trim", + "kind": "method", + "documentation": "trim(): java.lang.String", + "insertText": "trim" + } + ], + "constructorDefinition": { + "label": "String", + "kind": "constructor", + "documentation": "Constructor: String", + "insertText": "String" + } + }, + { + "label": "StringBuffer", + "kind": "class", + "documentation": "Class: StringBuffer", + "insertText": "StringBuffer", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuffer", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuffer", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuffer", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuffer", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuffer", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuffer", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuffer", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuffer", + "kind": "constructor", + "documentation": "Constructor: StringBuffer", + "insertText": "StringBuffer" + } + }, + { + "label": "StringBuilder", + "kind": "class", + "documentation": "Class: StringBuilder", + "insertText": "StringBuilder", + "properties": [ + { + "label": "append", + "kind": "method", + "documentation": "append(java.lang.CharSequence a, int b, int c | org.elasticsearch.painless.lookup.def a): java.lang.StringBuilder", + "insertText": "append" + }, + { + "label": "appendCodePoint", + "kind": "method", + "documentation": "appendCodePoint(int a): java.lang.StringBuilder", + "insertText": "appendCodePoint" + }, + { + "label": "capacity", + "kind": "method", + "documentation": "capacity(): int", + "insertText": "capacity" + }, + { + "label": "charAt", + "kind": "method", + "documentation": "charAt(int a): char", + "insertText": "charAt" + }, + { + "label": "chars", + "kind": "method", + "documentation": "chars(): java.util.stream.IntStream", + "insertText": "chars" + }, + { + "label": "codePointAt", + "kind": "method", + "documentation": "codePointAt(int a): int", + "insertText": "codePointAt" + }, + { + "label": "codePointBefore", + "kind": "method", + "documentation": "codePointBefore(int a): int", + "insertText": "codePointBefore" + }, + { + "label": "codePointCount", + "kind": "method", + "documentation": "codePointCount(int a, int b): int", + "insertText": "codePointCount" + }, + { + "label": "codePoints", + "kind": "method", + "documentation": "codePoints(): java.util.stream.IntStream", + "insertText": "codePoints" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "delete", + "kind": "method", + "documentation": "delete(int a, int b): java.lang.StringBuilder", + "insertText": "delete" + }, + { + "label": "deleteCharAt", + "kind": "method", + "documentation": "deleteCharAt(int a): java.lang.StringBuilder", + "insertText": "deleteCharAt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getChars", + "kind": "method", + "documentation": "getChars(int a, int b, [C c, int d): void", + "insertText": "getChars" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "indexOf" + }, + { + "label": "insert", + "kind": "method", + "documentation": "insert(int a, org.elasticsearch.painless.lookup.def b): java.lang.StringBuilder", + "insertText": "insert" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(java.lang.String a, int b | java.lang.String a): int", + "insertText": "lastIndexOf" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "offsetByCodePoints", + "kind": "method", + "documentation": "offsetByCodePoints(int a, int b): int", + "insertText": "offsetByCodePoints" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(int a, int b, java.lang.String c): java.lang.StringBuilder", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.util.regex.Pattern a, java.util.function.Function b): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(): java.lang.StringBuilder", + "insertText": "reverse" + }, + { + "label": "setCharAt", + "kind": "method", + "documentation": "setCharAt(int a, char b): void", + "insertText": "setCharAt" + }, + { + "label": "setLength", + "kind": "method", + "documentation": "setLength(int a): void", + "insertText": "setLength" + }, + { + "label": "subSequence", + "kind": "method", + "documentation": "subSequence(int a, int b): java.lang.CharSequence", + "insertText": "subSequence" + }, + { + "label": "substring", + "kind": "method", + "documentation": "substring(int a, int b | int a): java.lang.String", + "insertText": "substring" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringBuilder", + "kind": "constructor", + "documentation": "Constructor: StringBuilder", + "insertText": "StringBuilder" + } + }, + { + "label": "StringIndexOutOfBoundsException", + "kind": "class", + "documentation": "Class: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringIndexOutOfBoundsException", + "kind": "constructor", + "documentation": "Constructor: StringIndexOutOfBoundsException", + "insertText": "StringIndexOutOfBoundsException" + } + }, + { + "label": "System", + "kind": "class", + "documentation": "Class: System", + "insertText": "System", + "properties": [ + { + "label": "arraycopy", + "kind": "method", + "documentation": "arraycopy(java.lang.Object a, int b, java.lang.Object c, int d, int e): void", + "insertText": "arraycopy" + }, + { + "label": "currentTimeMillis", + "kind": "method", + "documentation": "currentTimeMillis(): long", + "insertText": "currentTimeMillis" + }, + { + "label": "nanoTime", + "kind": "method", + "documentation": "nanoTime(): long", + "insertText": "nanoTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TypeNotPresentException", + "kind": "class", + "documentation": "Class: TypeNotPresentException", + "insertText": "TypeNotPresentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "typeName", + "kind": "method", + "documentation": "typeName(): java.lang.String", + "insertText": "typeName" + } + ] + }, + { + "label": "UnsupportedOperationException", + "kind": "class", + "documentation": "Class: UnsupportedOperationException", + "insertText": "UnsupportedOperationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedOperationException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedOperationException", + "insertText": "UnsupportedOperationException" + } + }, + { + "label": "Void", + "kind": "class", + "documentation": "Class: Void", + "insertText": "Void", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BigDecimal", + "kind": "class", + "documentation": "Class: BigDecimal", + "insertText": "BigDecimal", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigDecimal", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigDecimal", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigDecimal", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(double a): java.math.BigDecimal", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(java.math.MathContext a): java.math.BigDecimal", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "add" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigDecimal a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): [Ljava.math.BigDecimal;", + "insertText": "divideAndRemainder" + }, + { + "label": "divideToIntegralValue", + "kind": "method", + "documentation": "divideToIntegralValue(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "divideToIntegralValue" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "min" + }, + { + "label": "movePointLeft", + "kind": "method", + "documentation": "movePointLeft(int a): java.math.BigDecimal", + "insertText": "movePointLeft" + }, + { + "label": "movePointRight", + "kind": "method", + "documentation": "movePointRight(int a): java.math.BigDecimal", + "insertText": "movePointRight" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(java.math.MathContext a): java.math.BigDecimal", + "insertText": "negate" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.math.MathContext a): java.math.BigDecimal", + "insertText": "plus" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a, java.math.MathContext b | int a): java.math.BigDecimal", + "insertText": "pow" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): int", + "insertText": "precision" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "remainder" + }, + { + "label": "round", + "kind": "method", + "documentation": "round(java.math.MathContext a): java.math.BigDecimal", + "insertText": "round" + }, + { + "label": "scale", + "kind": "method", + "documentation": "scale(): int", + "insertText": "scale" + }, + { + "label": "scaleByPowerOfTen", + "kind": "method", + "documentation": "scaleByPowerOfTen(int a): java.math.BigDecimal", + "insertText": "scaleByPowerOfTen" + }, + { + "label": "setScale", + "kind": "method", + "documentation": "setScale(int a, java.math.RoundingMode b | int a): java.math.BigDecimal", + "insertText": "setScale" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "stripTrailingZeros", + "kind": "method", + "documentation": "stripTrailingZeros(): java.math.BigDecimal", + "insertText": "stripTrailingZeros" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigDecimal a, java.math.MathContext b | java.math.BigDecimal a): java.math.BigDecimal", + "insertText": "subtract" + }, + { + "label": "toBigInteger", + "kind": "method", + "documentation": "toBigInteger(): java.math.BigInteger", + "insertText": "toBigInteger" + }, + { + "label": "toBigIntegerExact", + "kind": "method", + "documentation": "toBigIntegerExact(): java.math.BigInteger", + "insertText": "toBigIntegerExact" + }, + { + "label": "toEngineeringString", + "kind": "method", + "documentation": "toEngineeringString(): java.lang.String", + "insertText": "toEngineeringString" + }, + { + "label": "toPlainString", + "kind": "method", + "documentation": "toPlainString(): java.lang.String", + "insertText": "toPlainString" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "ulp", + "kind": "method", + "documentation": "ulp(): java.math.BigDecimal", + "insertText": "ulp" + } + ], + "constructorDefinition": { + "label": "BigDecimal", + "kind": "constructor", + "documentation": "Constructor: BigDecimal", + "insertText": "BigDecimal" + } + }, + { + "label": "BigInteger", + "kind": "class", + "documentation": "Class: BigInteger", + "insertText": "BigInteger", + "properties": [ + { + "label": "ONE", + "kind": "property", + "documentation": "ONE: java.math.BigInteger", + "insertText": "ONE" + }, + { + "label": "TEN", + "kind": "property", + "documentation": "TEN: java.math.BigInteger", + "insertText": "TEN" + }, + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.math.BigInteger", + "insertText": "ZERO" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(long a): java.math.BigInteger", + "insertText": "valueOf" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.math.BigInteger", + "insertText": "abs" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(java.math.BigInteger a): java.math.BigInteger", + "insertText": "add" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.math.BigInteger a): java.math.BigInteger", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.math.BigInteger a): java.math.BigInteger", + "insertText": "andNot" + }, + { + "label": "bitCount", + "kind": "method", + "documentation": "bitCount(): int", + "insertText": "bitCount" + }, + { + "label": "bitLength", + "kind": "method", + "documentation": "bitLength(): int", + "insertText": "bitLength" + }, + { + "label": "byteValue", + "kind": "method", + "documentation": "byteValue(): byte", + "insertText": "byteValue" + }, + { + "label": "byteValueExact", + "kind": "method", + "documentation": "byteValueExact(): byte", + "insertText": "byteValueExact" + }, + { + "label": "clearBit", + "kind": "method", + "documentation": "clearBit(int a): java.math.BigInteger", + "insertText": "clearBit" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.math.BigInteger a): int", + "insertText": "compareTo" + }, + { + "label": "divide", + "kind": "method", + "documentation": "divide(java.math.BigInteger a): java.math.BigInteger", + "insertText": "divide" + }, + { + "label": "divideAndRemainder", + "kind": "method", + "documentation": "divideAndRemainder(java.math.BigInteger a): [Ljava.math.BigInteger;", + "insertText": "divideAndRemainder" + }, + { + "label": "doubleValue", + "kind": "method", + "documentation": "doubleValue(): double", + "insertText": "doubleValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flipBit", + "kind": "method", + "documentation": "flipBit(int a): java.math.BigInteger", + "insertText": "flipBit" + }, + { + "label": "floatValue", + "kind": "method", + "documentation": "floatValue(): float", + "insertText": "floatValue" + }, + { + "label": "gcd", + "kind": "method", + "documentation": "gcd(java.math.BigInteger a): java.math.BigInteger", + "insertText": "gcd" + }, + { + "label": "getLowestSetBit", + "kind": "method", + "documentation": "getLowestSetBit(): int", + "insertText": "getLowestSetBit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intValue", + "kind": "method", + "documentation": "intValue(): int", + "insertText": "intValue" + }, + { + "label": "intValueExact", + "kind": "method", + "documentation": "intValueExact(): int", + "insertText": "intValueExact" + }, + { + "label": "longValue", + "kind": "method", + "documentation": "longValue(): long", + "insertText": "longValue" + }, + { + "label": "longValueExact", + "kind": "method", + "documentation": "longValueExact(): long", + "insertText": "longValueExact" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.math.BigInteger a): java.math.BigInteger", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.math.BigInteger a): java.math.BigInteger", + "insertText": "min" + }, + { + "label": "mod", + "kind": "method", + "documentation": "mod(java.math.BigInteger a): java.math.BigInteger", + "insertText": "mod" + }, + { + "label": "modInverse", + "kind": "method", + "documentation": "modInverse(java.math.BigInteger a): java.math.BigInteger", + "insertText": "modInverse" + }, + { + "label": "modPow", + "kind": "method", + "documentation": "modPow(java.math.BigInteger a, java.math.BigInteger b): java.math.BigInteger", + "insertText": "modPow" + }, + { + "label": "multiply", + "kind": "method", + "documentation": "multiply(java.math.BigInteger a): java.math.BigInteger", + "insertText": "multiply" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.math.BigInteger", + "insertText": "negate" + }, + { + "label": "not", + "kind": "method", + "documentation": "not(): java.math.BigInteger", + "insertText": "not" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.math.BigInteger a): java.math.BigInteger", + "insertText": "or" + }, + { + "label": "pow", + "kind": "method", + "documentation": "pow(int a): java.math.BigInteger", + "insertText": "pow" + }, + { + "label": "remainder", + "kind": "method", + "documentation": "remainder(java.math.BigInteger a): java.math.BigInteger", + "insertText": "remainder" + }, + { + "label": "setBit", + "kind": "method", + "documentation": "setBit(int a): java.math.BigInteger", + "insertText": "setBit" + }, + { + "label": "shiftLeft", + "kind": "method", + "documentation": "shiftLeft(int a): java.math.BigInteger", + "insertText": "shiftLeft" + }, + { + "label": "shiftRight", + "kind": "method", + "documentation": "shiftRight(int a): java.math.BigInteger", + "insertText": "shiftRight" + }, + { + "label": "shortValue", + "kind": "method", + "documentation": "shortValue(): short", + "insertText": "shortValue" + }, + { + "label": "shortValueExact", + "kind": "method", + "documentation": "shortValueExact(): short", + "insertText": "shortValueExact" + }, + { + "label": "signum", + "kind": "method", + "documentation": "signum(): int", + "insertText": "signum" + }, + { + "label": "subtract", + "kind": "method", + "documentation": "subtract(java.math.BigInteger a): java.math.BigInteger", + "insertText": "subtract" + }, + { + "label": "testBit", + "kind": "method", + "documentation": "testBit(int a): boolean", + "insertText": "testBit" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(int a): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.math.BigInteger a): java.math.BigInteger", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BigInteger", + "kind": "constructor", + "documentation": "Constructor: BigInteger", + "insertText": "BigInteger" + } + }, + { + "label": "MathContext", + "kind": "class", + "documentation": "Class: MathContext", + "insertText": "MathContext", + "properties": [ + { + "label": "DECIMAL128", + "kind": "property", + "documentation": "DECIMAL128: java.math.MathContext", + "insertText": "DECIMAL128" + }, + { + "label": "DECIMAL32", + "kind": "property", + "documentation": "DECIMAL32: java.math.MathContext", + "insertText": "DECIMAL32" + }, + { + "label": "DECIMAL64", + "kind": "property", + "documentation": "DECIMAL64: java.math.MathContext", + "insertText": "DECIMAL64" + }, + { + "label": "UNLIMITED", + "kind": "property", + "documentation": "UNLIMITED: java.math.MathContext", + "insertText": "UNLIMITED" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MathContext", + "kind": "constructor", + "documentation": "Constructor: MathContext", + "insertText": "MathContext" + } + }, + { + "label": "RoundingMode", + "kind": "class", + "documentation": "Class: RoundingMode", + "insertText": "RoundingMode", + "properties": [ + { + "label": "CEILING", + "kind": "property", + "documentation": "CEILING: java.math.RoundingMode", + "insertText": "CEILING" + }, + { + "label": "DOWN", + "kind": "property", + "documentation": "DOWN: java.math.RoundingMode", + "insertText": "DOWN" + }, + { + "label": "FLOOR", + "kind": "property", + "documentation": "FLOOR: java.math.RoundingMode", + "insertText": "FLOOR" + }, + { + "label": "HALF_DOWN", + "kind": "property", + "documentation": "HALF_DOWN: java.math.RoundingMode", + "insertText": "HALF_DOWN" + }, + { + "label": "HALF_EVEN", + "kind": "property", + "documentation": "HALF_EVEN: java.math.RoundingMode", + "insertText": "HALF_EVEN" + }, + { + "label": "HALF_UP", + "kind": "property", + "documentation": "HALF_UP: java.math.RoundingMode", + "insertText": "HALF_UP" + }, + { + "label": "UNNECESSARY", + "kind": "property", + "documentation": "UNNECESSARY: java.math.RoundingMode", + "insertText": "UNNECESSARY" + }, + { + "label": "UP", + "kind": "property", + "documentation": "UP: java.math.RoundingMode", + "insertText": "UP" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.math.RoundingMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.math.RoundingMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Annotation", + "kind": "class", + "documentation": "Class: Annotation", + "insertText": "Annotation", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Annotation", + "kind": "constructor", + "documentation": "Constructor: Annotation", + "insertText": "Annotation" + } + }, + { + "label": "AttributedCharacterIterator", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator", + "insertText": "AttributedCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getAllAttributeKeys", + "kind": "method", + "documentation": "getAllAttributeKeys(): java.util.Set", + "insertText": "getAllAttributeKeys" + }, + { + "label": "getAttribute", + "kind": "method", + "documentation": "getAttribute(java.text.AttributedCharacterIterator$Attribute a): org.elasticsearch.painless.lookup.def", + "insertText": "getAttribute" + }, + { + "label": "getAttributes", + "kind": "method", + "documentation": "getAttributes(): java.util.Map", + "insertText": "getAttributes" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(java.util.Set a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(java.util.Set a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedCharacterIterator.Attribute", + "kind": "class", + "documentation": "Class: AttributedCharacterIterator.Attribute", + "insertText": "AttributedCharacterIterator.Attribute", + "properties": [ + { + "label": "INPUT_METHOD_SEGMENT", + "kind": "property", + "documentation": "INPUT_METHOD_SEGMENT: java.text.AttributedCharacterIterator$Attribute", + "insertText": "INPUT_METHOD_SEGMENT" + }, + { + "label": "LANGUAGE", + "kind": "property", + "documentation": "LANGUAGE: java.text.AttributedCharacterIterator$Attribute", + "insertText": "LANGUAGE" + }, + { + "label": "READING", + "kind": "property", + "documentation": "READING: java.text.AttributedCharacterIterator$Attribute", + "insertText": "READING" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AttributedString", + "kind": "class", + "documentation": "Class: AttributedString", + "insertText": "AttributedString", + "properties": [ + { + "label": "addAttribute", + "kind": "method", + "documentation": "addAttribute(java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b, int c, int d | java.text.AttributedCharacterIterator$Attribute a, java.lang.Object b): void", + "insertText": "addAttribute" + }, + { + "label": "addAttributes", + "kind": "method", + "documentation": "addAttributes(java.util.Map a, int b, int c): void", + "insertText": "addAttributes" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getIterator", + "kind": "method", + "documentation": "getIterator([Ljava.text.AttributedCharacterIterator$Attribute; a, int b, int c | [Ljava.text.AttributedCharacterIterator$Attribute; a): java.text.AttributedCharacterIterator", + "insertText": "getIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AttributedString", + "kind": "constructor", + "documentation": "Constructor: AttributedString", + "insertText": "AttributedString" + } + }, + { + "label": "Bidi", + "kind": "class", + "documentation": "Class: Bidi", + "insertText": "Bidi", + "properties": [ + { + "label": "DIRECTION_DEFAULT_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_DEFAULT_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_DEFAULT_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_DEFAULT_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_DEFAULT_RIGHT_TO_LEFT" + }, + { + "label": "DIRECTION_LEFT_TO_RIGHT", + "kind": "property", + "documentation": "DIRECTION_LEFT_TO_RIGHT: int", + "insertText": "DIRECTION_LEFT_TO_RIGHT" + }, + { + "label": "DIRECTION_RIGHT_TO_LEFT", + "kind": "property", + "documentation": "DIRECTION_RIGHT_TO_LEFT: int", + "insertText": "DIRECTION_RIGHT_TO_LEFT" + }, + { + "label": "reorderVisually", + "kind": "method", + "documentation": "reorderVisually([B a, int b, [Ljava.lang.Object; c, int d, int e): void", + "insertText": "reorderVisually" + }, + { + "label": "requiresBidi", + "kind": "method", + "documentation": "requiresBidi([C a, int b, int c): boolean", + "insertText": "requiresBidi" + }, + { + "label": "baseIsLeftToRight", + "kind": "method", + "documentation": "baseIsLeftToRight(): boolean", + "insertText": "baseIsLeftToRight" + }, + { + "label": "createLineBidi", + "kind": "method", + "documentation": "createLineBidi(int a, int b): java.text.Bidi", + "insertText": "createLineBidi" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseLevel", + "kind": "method", + "documentation": "getBaseLevel(): int", + "insertText": "getBaseLevel" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLevelAt", + "kind": "method", + "documentation": "getLevelAt(int a): int", + "insertText": "getLevelAt" + }, + { + "label": "getRunCount", + "kind": "method", + "documentation": "getRunCount(): int", + "insertText": "getRunCount" + }, + { + "label": "getRunLevel", + "kind": "method", + "documentation": "getRunLevel(int a): int", + "insertText": "getRunLevel" + }, + { + "label": "getRunLimit", + "kind": "method", + "documentation": "getRunLimit(int a): int", + "insertText": "getRunLimit" + }, + { + "label": "getRunStart", + "kind": "method", + "documentation": "getRunStart(int a): int", + "insertText": "getRunStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeftToRight", + "kind": "method", + "documentation": "isLeftToRight(): boolean", + "insertText": "isLeftToRight" + }, + { + "label": "isMixed", + "kind": "method", + "documentation": "isMixed(): boolean", + "insertText": "isMixed" + }, + { + "label": "isRightToLeft", + "kind": "method", + "documentation": "isRightToLeft(): boolean", + "insertText": "isRightToLeft" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Bidi", + "kind": "constructor", + "documentation": "Constructor: Bidi", + "insertText": "Bidi" + } + }, + { + "label": "BreakIterator", + "kind": "class", + "documentation": "Class: BreakIterator", + "insertText": "BreakIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: int", + "insertText": "DONE" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCharacterInstance", + "kind": "method", + "documentation": "getCharacterInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getCharacterInstance" + }, + { + "label": "getLineInstance", + "kind": "method", + "documentation": "getLineInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getLineInstance" + }, + { + "label": "getSentenceInstance", + "kind": "method", + "documentation": "getSentenceInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getSentenceInstance" + }, + { + "label": "getWordInstance", + "kind": "method", + "documentation": "getWordInstance(java.util.Locale a): java.text.BreakIterator", + "insertText": "getWordInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): int", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): int", + "insertText": "first" + }, + { + "label": "following", + "kind": "method", + "documentation": "following(int a): int", + "insertText": "following" + }, + { + "label": "getText", + "kind": "method", + "documentation": "getText(): java.text.CharacterIterator", + "insertText": "getText" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isBoundary", + "kind": "method", + "documentation": "isBoundary(int a): boolean", + "insertText": "isBoundary" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): int", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(int a): int", + "insertText": "next" + }, + { + "label": "preceding", + "kind": "method", + "documentation": "preceding(int a): int", + "insertText": "preceding" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CharacterIterator", + "kind": "class", + "documentation": "Class: CharacterIterator", + "insertText": "CharacterIterator", + "properties": [ + { + "label": "DONE", + "kind": "property", + "documentation": "DONE: char", + "insertText": "DONE" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChoiceFormat", + "kind": "class", + "documentation": "Class: ChoiceFormat", + "insertText": "ChoiceFormat", + "properties": [ + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(double a, boolean b | double a): double", + "insertText": "nextDouble" + }, + { + "label": "previousDouble", + "kind": "method", + "documentation": "previousDouble(double a): double", + "insertText": "previousDouble" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "getFormats" + }, + { + "label": "getLimits", + "kind": "method", + "documentation": "getLimits(): [D", + "insertText": "getLimits" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setChoices", + "kind": "method", + "documentation": "setChoices([D a, [Ljava.lang.String; b): void", + "insertText": "setChoices" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ChoiceFormat", + "kind": "constructor", + "documentation": "Constructor: ChoiceFormat", + "insertText": "ChoiceFormat" + } + }, + { + "label": "CollationElementIterator", + "kind": "class", + "documentation": "Class: CollationElementIterator", + "insertText": "CollationElementIterator", + "properties": [ + { + "label": "NULLORDER", + "kind": "property", + "documentation": "NULLORDER: int", + "insertText": "NULLORDER" + }, + { + "label": "primaryOrder", + "kind": "method", + "documentation": "primaryOrder(int a): int", + "insertText": "primaryOrder" + }, + { + "label": "secondaryOrder", + "kind": "method", + "documentation": "secondaryOrder(int a): short", + "insertText": "secondaryOrder" + }, + { + "label": "tertiaryOrder", + "kind": "method", + "documentation": "tertiaryOrder(int a): short", + "insertText": "tertiaryOrder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getMaxExpansion", + "kind": "method", + "documentation": "getMaxExpansion(int a): int", + "insertText": "getMaxExpansion" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): int", + "insertText": "getOffset" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): int", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): int", + "insertText": "previous" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): void", + "insertText": "reset" + }, + { + "label": "setOffset", + "kind": "method", + "documentation": "setOffset(int a): void", + "insertText": "setOffset" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "CollationKey", + "kind": "class", + "documentation": "Class: CollationKey", + "insertText": "CollationKey", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.text.CollationKey a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSourceString", + "kind": "method", + "documentation": "getSourceString(): java.lang.String", + "insertText": "getSourceString" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collator", + "kind": "class", + "documentation": "Class: Collator", + "insertText": "Collator", + "properties": [ + { + "label": "CANONICAL_DECOMPOSITION", + "kind": "property", + "documentation": "CANONICAL_DECOMPOSITION: int", + "insertText": "CANONICAL_DECOMPOSITION" + }, + { + "label": "FULL_DECOMPOSITION", + "kind": "property", + "documentation": "FULL_DECOMPOSITION: int", + "insertText": "FULL_DECOMPOSITION" + }, + { + "label": "IDENTICAL", + "kind": "property", + "documentation": "IDENTICAL: int", + "insertText": "IDENTICAL" + }, + { + "label": "NO_DECOMPOSITION", + "kind": "property", + "documentation": "NO_DECOMPOSITION: int", + "insertText": "NO_DECOMPOSITION" + }, + { + "label": "PRIMARY", + "kind": "property", + "documentation": "PRIMARY: int", + "insertText": "PRIMARY" + }, + { + "label": "SECONDARY", + "kind": "property", + "documentation": "SECONDARY: int", + "insertText": "SECONDARY" + }, + { + "label": "TERTIARY", + "kind": "property", + "documentation": "TERTIARY: int", + "insertText": "TERTIARY" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.Collator", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat", + "kind": "class", + "documentation": "Class: DateFormat", + "insertText": "DateFormat", + "properties": [ + { + "label": "AM_PM_FIELD", + "kind": "property", + "documentation": "AM_PM_FIELD: int", + "insertText": "AM_PM_FIELD" + }, + { + "label": "DATE_FIELD", + "kind": "property", + "documentation": "DATE_FIELD: int", + "insertText": "DATE_FIELD" + }, + { + "label": "DAY_OF_WEEK_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_FIELD: int", + "insertText": "DAY_OF_WEEK_FIELD" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH_FIELD", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH_FIELD: int", + "insertText": "DAY_OF_WEEK_IN_MONTH_FIELD" + }, + { + "label": "DAY_OF_YEAR_FIELD", + "kind": "property", + "documentation": "DAY_OF_YEAR_FIELD: int", + "insertText": "DAY_OF_YEAR_FIELD" + }, + { + "label": "DEFAULT", + "kind": "property", + "documentation": "DEFAULT: int", + "insertText": "DEFAULT" + }, + { + "label": "ERA_FIELD", + "kind": "property", + "documentation": "ERA_FIELD: int", + "insertText": "ERA_FIELD" + }, + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: int", + "insertText": "FULL" + }, + { + "label": "HOUR0_FIELD", + "kind": "property", + "documentation": "HOUR0_FIELD: int", + "insertText": "HOUR0_FIELD" + }, + { + "label": "HOUR1_FIELD", + "kind": "property", + "documentation": "HOUR1_FIELD: int", + "insertText": "HOUR1_FIELD" + }, + { + "label": "HOUR_OF_DAY0_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY0_FIELD: int", + "insertText": "HOUR_OF_DAY0_FIELD" + }, + { + "label": "HOUR_OF_DAY1_FIELD", + "kind": "property", + "documentation": "HOUR_OF_DAY1_FIELD: int", + "insertText": "HOUR_OF_DAY1_FIELD" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: int", + "insertText": "MEDIUM" + }, + { + "label": "MILLISECOND_FIELD", + "kind": "property", + "documentation": "MILLISECOND_FIELD: int", + "insertText": "MILLISECOND_FIELD" + }, + { + "label": "MINUTE_FIELD", + "kind": "property", + "documentation": "MINUTE_FIELD: int", + "insertText": "MINUTE_FIELD" + }, + { + "label": "MONTH_FIELD", + "kind": "property", + "documentation": "MONTH_FIELD: int", + "insertText": "MONTH_FIELD" + }, + { + "label": "SECOND_FIELD", + "kind": "property", + "documentation": "SECOND_FIELD: int", + "insertText": "SECOND_FIELD" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "TIMEZONE_FIELD", + "kind": "property", + "documentation": "TIMEZONE_FIELD: int", + "insertText": "TIMEZONE_FIELD" + }, + { + "label": "WEEK_OF_MONTH_FIELD", + "kind": "property", + "documentation": "WEEK_OF_MONTH_FIELD: int", + "insertText": "WEEK_OF_MONTH_FIELD" + }, + { + "label": "WEEK_OF_YEAR_FIELD", + "kind": "property", + "documentation": "WEEK_OF_YEAR_FIELD: int", + "insertText": "WEEK_OF_YEAR_FIELD" + }, + { + "label": "YEAR_FIELD", + "kind": "property", + "documentation": "YEAR_FIELD: int", + "insertText": "YEAR_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDateInstance", + "kind": "method", + "documentation": "getDateInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getDateInstance" + }, + { + "label": "getDateTimeInstance", + "kind": "method", + "documentation": "getDateTimeInstance(int a, int b, java.util.Locale c | int a, int b): java.text.DateFormat", + "insertText": "getDateTimeInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(): java.text.DateFormat", + "insertText": "getInstance" + }, + { + "label": "getTimeInstance", + "kind": "method", + "documentation": "getTimeInstance(int a, java.util.Locale b | int a): java.text.DateFormat", + "insertText": "getTimeInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormat.Field", + "kind": "class", + "documentation": "Class: DateFormat.Field", + "insertText": "DateFormat.Field", + "properties": [ + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: java.text.DateFormat$Field", + "insertText": "AM_PM" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: java.text.DateFormat$Field", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.text.DateFormat$Field", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.text.DateFormat$Field", + "insertText": "ERA" + }, + { + "label": "HOUR0", + "kind": "property", + "documentation": "HOUR0: java.text.DateFormat$Field", + "insertText": "HOUR0" + }, + { + "label": "HOUR1", + "kind": "property", + "documentation": "HOUR1: java.text.DateFormat$Field", + "insertText": "HOUR1" + }, + { + "label": "HOUR_OF_DAY0", + "kind": "property", + "documentation": "HOUR_OF_DAY0: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY0" + }, + { + "label": "HOUR_OF_DAY1", + "kind": "property", + "documentation": "HOUR_OF_DAY1: java.text.DateFormat$Field", + "insertText": "HOUR_OF_DAY1" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: java.text.DateFormat$Field", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: java.text.DateFormat$Field", + "insertText": "MINUTE" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: java.text.DateFormat$Field", + "insertText": "MONTH" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: java.text.DateFormat$Field", + "insertText": "SECOND" + }, + { + "label": "TIME_ZONE", + "kind": "property", + "documentation": "TIME_ZONE: java.text.DateFormat$Field", + "insertText": "TIME_ZONE" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: java.text.DateFormat$Field", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: java.text.DateFormat$Field", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.text.DateFormat$Field", + "insertText": "YEAR" + }, + { + "label": "ofCalendarField", + "kind": "method", + "documentation": "ofCalendarField(int a): java.text.DateFormat$Field", + "insertText": "ofCalendarField" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCalendarField", + "kind": "method", + "documentation": "getCalendarField(): int", + "insertText": "getCalendarField" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateFormatSymbols", + "kind": "class", + "documentation": "Class: DateFormatSymbols", + "insertText": "DateFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DateFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAmPmStrings", + "kind": "method", + "documentation": "getAmPmStrings(): [Ljava.lang.String;", + "insertText": "getAmPmStrings" + }, + { + "label": "getEras", + "kind": "method", + "documentation": "getEras(): [Ljava.lang.String;", + "insertText": "getEras" + }, + { + "label": "getLocalPatternChars", + "kind": "method", + "documentation": "getLocalPatternChars(): java.lang.String", + "insertText": "getLocalPatternChars" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): [Ljava.lang.String;", + "insertText": "getMonths" + }, + { + "label": "getShortMonths", + "kind": "method", + "documentation": "getShortMonths(): [Ljava.lang.String;", + "insertText": "getShortMonths" + }, + { + "label": "getShortWeekdays", + "kind": "method", + "documentation": "getShortWeekdays(): [Ljava.lang.String;", + "insertText": "getShortWeekdays" + }, + { + "label": "getWeekdays", + "kind": "method", + "documentation": "getWeekdays(): [Ljava.lang.String;", + "insertText": "getWeekdays" + }, + { + "label": "getZoneStrings", + "kind": "method", + "documentation": "getZoneStrings(): [[Ljava.lang.String;", + "insertText": "getZoneStrings" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setAmPmStrings", + "kind": "method", + "documentation": "setAmPmStrings([Ljava.lang.String; a): void", + "insertText": "setAmPmStrings" + }, + { + "label": "setEras", + "kind": "method", + "documentation": "setEras([Ljava.lang.String; a): void", + "insertText": "setEras" + }, + { + "label": "setLocalPatternChars", + "kind": "method", + "documentation": "setLocalPatternChars(java.lang.String a): void", + "insertText": "setLocalPatternChars" + }, + { + "label": "setMonths", + "kind": "method", + "documentation": "setMonths([Ljava.lang.String; a): void", + "insertText": "setMonths" + }, + { + "label": "setShortMonths", + "kind": "method", + "documentation": "setShortMonths([Ljava.lang.String; a): void", + "insertText": "setShortMonths" + }, + { + "label": "setShortWeekdays", + "kind": "method", + "documentation": "setShortWeekdays([Ljava.lang.String; a): void", + "insertText": "setShortWeekdays" + }, + { + "label": "setWeekdays", + "kind": "method", + "documentation": "setWeekdays([Ljava.lang.String; a): void", + "insertText": "setWeekdays" + }, + { + "label": "setZoneStrings", + "kind": "method", + "documentation": "setZoneStrings([[Ljava.lang.String; a): void", + "insertText": "setZoneStrings" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DateFormatSymbols", + "insertText": "DateFormatSymbols" + } + }, + { + "label": "DecimalFormat", + "kind": "class", + "documentation": "Class: DecimalFormat", + "insertText": "DecimalFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getDecimalFormatSymbols", + "kind": "method", + "documentation": "getDecimalFormatSymbols(): java.text.DecimalFormatSymbols", + "insertText": "getDecimalFormatSymbols" + }, + { + "label": "getGroupingSize", + "kind": "method", + "documentation": "getGroupingSize(): int", + "insertText": "getGroupingSize" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getMultiplier", + "kind": "method", + "documentation": "getMultiplier(): int", + "insertText": "getMultiplier" + }, + { + "label": "getNegativePrefix", + "kind": "method", + "documentation": "getNegativePrefix(): java.lang.String", + "insertText": "getNegativePrefix" + }, + { + "label": "getNegativeSuffix", + "kind": "method", + "documentation": "getNegativeSuffix(): java.lang.String", + "insertText": "getNegativeSuffix" + }, + { + "label": "getPositivePrefix", + "kind": "method", + "documentation": "getPositivePrefix(): java.lang.String", + "insertText": "getPositivePrefix" + }, + { + "label": "getPositiveSuffix", + "kind": "method", + "documentation": "getPositiveSuffix(): java.lang.String", + "insertText": "getPositiveSuffix" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "isDecimalSeparatorAlwaysShown(): boolean", + "insertText": "isDecimalSeparatorAlwaysShown" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseBigDecimal", + "kind": "method", + "documentation": "isParseBigDecimal(): boolean", + "insertText": "isParseBigDecimal" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setDecimalFormatSymbols", + "kind": "method", + "documentation": "setDecimalFormatSymbols(java.text.DecimalFormatSymbols a): void", + "insertText": "setDecimalFormatSymbols" + }, + { + "label": "setDecimalSeparatorAlwaysShown", + "kind": "method", + "documentation": "setDecimalSeparatorAlwaysShown(boolean a): void", + "insertText": "setDecimalSeparatorAlwaysShown" + }, + { + "label": "setGroupingSize", + "kind": "method", + "documentation": "setGroupingSize(int a): void", + "insertText": "setGroupingSize" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setMultiplier", + "kind": "method", + "documentation": "setMultiplier(int a): void", + "insertText": "setMultiplier" + }, + { + "label": "setNegativePrefix", + "kind": "method", + "documentation": "setNegativePrefix(java.lang.String a): void", + "insertText": "setNegativePrefix" + }, + { + "label": "setNegativeSuffix", + "kind": "method", + "documentation": "setNegativeSuffix(java.lang.String a): void", + "insertText": "setNegativeSuffix" + }, + { + "label": "setParseBigDecimal", + "kind": "method", + "documentation": "setParseBigDecimal(boolean a): void", + "insertText": "setParseBigDecimal" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setPositivePrefix", + "kind": "method", + "documentation": "setPositivePrefix(java.lang.String a): void", + "insertText": "setPositivePrefix" + }, + { + "label": "setPositiveSuffix", + "kind": "method", + "documentation": "setPositiveSuffix(java.lang.String a): void", + "insertText": "setPositiveSuffix" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormat", + "kind": "constructor", + "documentation": "Constructor: DecimalFormat", + "insertText": "DecimalFormat" + } + }, + { + "label": "DecimalFormatSymbols", + "kind": "class", + "documentation": "Class: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols", + "properties": [ + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.DecimalFormatSymbols", + "insertText": "getInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getCurrencySymbol", + "kind": "method", + "documentation": "getCurrencySymbol(): java.lang.String", + "insertText": "getCurrencySymbol" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getDigit", + "kind": "method", + "documentation": "getDigit(): char", + "insertText": "getDigit" + }, + { + "label": "getExponentSeparator", + "kind": "method", + "documentation": "getExponentSeparator(): java.lang.String", + "insertText": "getExponentSeparator" + }, + { + "label": "getGroupingSeparator", + "kind": "method", + "documentation": "getGroupingSeparator(): char", + "insertText": "getGroupingSeparator" + }, + { + "label": "getInfinity", + "kind": "method", + "documentation": "getInfinity(): java.lang.String", + "insertText": "getInfinity" + }, + { + "label": "getInternationalCurrencySymbol", + "kind": "method", + "documentation": "getInternationalCurrencySymbol(): java.lang.String", + "insertText": "getInternationalCurrencySymbol" + }, + { + "label": "getMinusSign", + "kind": "method", + "documentation": "getMinusSign(): char", + "insertText": "getMinusSign" + }, + { + "label": "getMonetaryDecimalSeparator", + "kind": "method", + "documentation": "getMonetaryDecimalSeparator(): char", + "insertText": "getMonetaryDecimalSeparator" + }, + { + "label": "getNaN", + "kind": "method", + "documentation": "getNaN(): java.lang.String", + "insertText": "getNaN" + }, + { + "label": "getPatternSeparator", + "kind": "method", + "documentation": "getPatternSeparator(): char", + "insertText": "getPatternSeparator" + }, + { + "label": "getPerMill", + "kind": "method", + "documentation": "getPerMill(): char", + "insertText": "getPerMill" + }, + { + "label": "getPercent", + "kind": "method", + "documentation": "getPercent(): char", + "insertText": "getPercent" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setCurrencySymbol", + "kind": "method", + "documentation": "setCurrencySymbol(java.lang.String a): void", + "insertText": "setCurrencySymbol" + }, + { + "label": "setDecimalSeparator", + "kind": "method", + "documentation": "setDecimalSeparator(char a): void", + "insertText": "setDecimalSeparator" + }, + { + "label": "setDigit", + "kind": "method", + "documentation": "setDigit(char a): void", + "insertText": "setDigit" + }, + { + "label": "setExponentSeparator", + "kind": "method", + "documentation": "setExponentSeparator(java.lang.String a): void", + "insertText": "setExponentSeparator" + }, + { + "label": "setGroupingSeparator", + "kind": "method", + "documentation": "setGroupingSeparator(char a): void", + "insertText": "setGroupingSeparator" + }, + { + "label": "setInfinity", + "kind": "method", + "documentation": "setInfinity(java.lang.String a): void", + "insertText": "setInfinity" + }, + { + "label": "setInternationalCurrencySymbol", + "kind": "method", + "documentation": "setInternationalCurrencySymbol(java.lang.String a): void", + "insertText": "setInternationalCurrencySymbol" + }, + { + "label": "setMinusSign", + "kind": "method", + "documentation": "setMinusSign(char a): void", + "insertText": "setMinusSign" + }, + { + "label": "setMonetaryDecimalSeparator", + "kind": "method", + "documentation": "setMonetaryDecimalSeparator(char a): void", + "insertText": "setMonetaryDecimalSeparator" + }, + { + "label": "setNaN", + "kind": "method", + "documentation": "setNaN(java.lang.String a): void", + "insertText": "setNaN" + }, + { + "label": "setPatternSeparator", + "kind": "method", + "documentation": "setPatternSeparator(char a): void", + "insertText": "setPatternSeparator" + }, + { + "label": "setPerMill", + "kind": "method", + "documentation": "setPerMill(char a): void", + "insertText": "setPerMill" + }, + { + "label": "setPercent", + "kind": "method", + "documentation": "setPercent(char a): void", + "insertText": "setPercent" + }, + { + "label": "setZeroDigit", + "kind": "method", + "documentation": "setZeroDigit(char a): void", + "insertText": "setZeroDigit" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DecimalFormatSymbols", + "kind": "constructor", + "documentation": "Constructor: DecimalFormatSymbols", + "insertText": "DecimalFormatSymbols" + } + }, + { + "label": "FieldPosition", + "kind": "class", + "documentation": "Class: FieldPosition", + "insertText": "FieldPosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getField", + "kind": "method", + "documentation": "getField(): int", + "insertText": "getField" + }, + { + "label": "getFieldAttribute", + "kind": "method", + "documentation": "getFieldAttribute(): java.text.Format$Field", + "insertText": "getFieldAttribute" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setBeginIndex", + "kind": "method", + "documentation": "setBeginIndex(int a): void", + "insertText": "setBeginIndex" + }, + { + "label": "setEndIndex", + "kind": "method", + "documentation": "setEndIndex(int a): void", + "insertText": "setEndIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FieldPosition", + "kind": "constructor", + "documentation": "Constructor: FieldPosition", + "insertText": "FieldPosition" + } + }, + { + "label": "Format", + "kind": "class", + "documentation": "Class: Format", + "insertText": "Format", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Format.Field", + "kind": "class", + "documentation": "Class: Format.Field", + "insertText": "Format.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat", + "kind": "class", + "documentation": "Class: MessageFormat", + "insertText": "MessageFormat", + "properties": [ + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.String a, [Ljava.lang.Object; b): java.lang.String", + "insertText": "format" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getFormats", + "kind": "method", + "documentation": "getFormats(): [Ljava.text.Format;", + "insertText": "getFormats" + }, + { + "label": "getFormatsByArgumentIndex", + "kind": "method", + "documentation": "getFormatsByArgumentIndex(): [Ljava.text.Format;", + "insertText": "getFormatsByArgumentIndex" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): [Ljava.lang.Object;", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setFormat", + "kind": "method", + "documentation": "setFormat(int a, java.text.Format b): void", + "insertText": "setFormat" + }, + { + "label": "setFormatByArgumentIndex", + "kind": "method", + "documentation": "setFormatByArgumentIndex(int a, java.text.Format b): void", + "insertText": "setFormatByArgumentIndex" + }, + { + "label": "setFormats", + "kind": "method", + "documentation": "setFormats([Ljava.text.Format; a): void", + "insertText": "setFormats" + }, + { + "label": "setFormatsByArgumentIndex", + "kind": "method", + "documentation": "setFormatsByArgumentIndex([Ljava.text.Format; a): void", + "insertText": "setFormatsByArgumentIndex" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): void", + "insertText": "setLocale" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MessageFormat.Field", + "kind": "class", + "documentation": "Class: MessageFormat.Field", + "insertText": "MessageFormat.Field", + "properties": [ + { + "label": "ARGUMENT", + "kind": "property", + "documentation": "ARGUMENT: java.text.MessageFormat$Field", + "insertText": "ARGUMENT" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer", + "kind": "class", + "documentation": "Class: Normalizer", + "insertText": "Normalizer", + "properties": [ + { + "label": "isNormalized", + "kind": "method", + "documentation": "isNormalized(java.lang.CharSequence a, java.text.Normalizer$Form b): boolean", + "insertText": "isNormalized" + }, + { + "label": "normalize", + "kind": "method", + "documentation": "normalize(java.lang.CharSequence a, java.text.Normalizer$Form b): java.lang.String", + "insertText": "normalize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Normalizer.Form", + "kind": "class", + "documentation": "Class: Normalizer.Form", + "insertText": "Normalizer.Form", + "properties": [ + { + "label": "NFC", + "kind": "property", + "documentation": "NFC: java.text.Normalizer$Form", + "insertText": "NFC" + }, + { + "label": "NFD", + "kind": "property", + "documentation": "NFD: java.text.Normalizer$Form", + "insertText": "NFD" + }, + { + "label": "NFKC", + "kind": "property", + "documentation": "NFKC: java.text.Normalizer$Form", + "insertText": "NFKC" + }, + { + "label": "NFKD", + "kind": "property", + "documentation": "NFKD: java.text.Normalizer$Form", + "insertText": "NFKD" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.text.Normalizer$Form", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.text.Normalizer$Form;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat", + "kind": "class", + "documentation": "Class: NumberFormat", + "insertText": "NumberFormat", + "properties": [ + { + "label": "FRACTION_FIELD", + "kind": "property", + "documentation": "FRACTION_FIELD: int", + "insertText": "FRACTION_FIELD" + }, + { + "label": "INTEGER_FIELD", + "kind": "property", + "documentation": "INTEGER_FIELD: int", + "insertText": "INTEGER_FIELD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getCurrencyInstance", + "kind": "method", + "documentation": "getCurrencyInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getCurrencyInstance" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getInstance" + }, + { + "label": "getIntegerInstance", + "kind": "method", + "documentation": "getIntegerInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getIntegerInstance" + }, + { + "label": "getNumberInstance", + "kind": "method", + "documentation": "getNumberInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getNumberInstance" + }, + { + "label": "getPercentInstance", + "kind": "method", + "documentation": "getPercentInstance(java.util.Locale a): java.text.NumberFormat", + "insertText": "getPercentInstance" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "getCurrency", + "kind": "method", + "documentation": "getCurrency(): java.util.Currency", + "insertText": "getCurrency" + }, + { + "label": "getMaximumFractionDigits", + "kind": "method", + "documentation": "getMaximumFractionDigits(): int", + "insertText": "getMaximumFractionDigits" + }, + { + "label": "getMaximumIntegerDigits", + "kind": "method", + "documentation": "getMaximumIntegerDigits(): int", + "insertText": "getMaximumIntegerDigits" + }, + { + "label": "getMinimumFractionDigits", + "kind": "method", + "documentation": "getMinimumFractionDigits(): int", + "insertText": "getMinimumFractionDigits" + }, + { + "label": "getMinimumIntegerDigits", + "kind": "method", + "documentation": "getMinimumIntegerDigits(): int", + "insertText": "getMinimumIntegerDigits" + }, + { + "label": "getRoundingMode", + "kind": "method", + "documentation": "getRoundingMode(): java.math.RoundingMode", + "insertText": "getRoundingMode" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGroupingUsed", + "kind": "method", + "documentation": "isGroupingUsed(): boolean", + "insertText": "isGroupingUsed" + }, + { + "label": "isParseIntegerOnly", + "kind": "method", + "documentation": "isParseIntegerOnly(): boolean", + "insertText": "isParseIntegerOnly" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Number", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "setCurrency", + "kind": "method", + "documentation": "setCurrency(java.util.Currency a): void", + "insertText": "setCurrency" + }, + { + "label": "setGroupingUsed", + "kind": "method", + "documentation": "setGroupingUsed(boolean a): void", + "insertText": "setGroupingUsed" + }, + { + "label": "setMaximumFractionDigits", + "kind": "method", + "documentation": "setMaximumFractionDigits(int a): void", + "insertText": "setMaximumFractionDigits" + }, + { + "label": "setMaximumIntegerDigits", + "kind": "method", + "documentation": "setMaximumIntegerDigits(int a): void", + "insertText": "setMaximumIntegerDigits" + }, + { + "label": "setMinimumFractionDigits", + "kind": "method", + "documentation": "setMinimumFractionDigits(int a): void", + "insertText": "setMinimumFractionDigits" + }, + { + "label": "setMinimumIntegerDigits", + "kind": "method", + "documentation": "setMinimumIntegerDigits(int a): void", + "insertText": "setMinimumIntegerDigits" + }, + { + "label": "setParseIntegerOnly", + "kind": "method", + "documentation": "setParseIntegerOnly(boolean a): void", + "insertText": "setParseIntegerOnly" + }, + { + "label": "setRoundingMode", + "kind": "method", + "documentation": "setRoundingMode(java.math.RoundingMode a): void", + "insertText": "setRoundingMode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NumberFormat.Field", + "kind": "class", + "documentation": "Class: NumberFormat.Field", + "insertText": "NumberFormat.Field", + "properties": [ + { + "label": "CURRENCY", + "kind": "property", + "documentation": "CURRENCY: java.text.NumberFormat$Field", + "insertText": "CURRENCY" + }, + { + "label": "DECIMAL_SEPARATOR", + "kind": "property", + "documentation": "DECIMAL_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "DECIMAL_SEPARATOR" + }, + { + "label": "EXPONENT", + "kind": "property", + "documentation": "EXPONENT: java.text.NumberFormat$Field", + "insertText": "EXPONENT" + }, + { + "label": "EXPONENT_SIGN", + "kind": "property", + "documentation": "EXPONENT_SIGN: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SIGN" + }, + { + "label": "EXPONENT_SYMBOL", + "kind": "property", + "documentation": "EXPONENT_SYMBOL: java.text.NumberFormat$Field", + "insertText": "EXPONENT_SYMBOL" + }, + { + "label": "FRACTION", + "kind": "property", + "documentation": "FRACTION: java.text.NumberFormat$Field", + "insertText": "FRACTION" + }, + { + "label": "GROUPING_SEPARATOR", + "kind": "property", + "documentation": "GROUPING_SEPARATOR: java.text.NumberFormat$Field", + "insertText": "GROUPING_SEPARATOR" + }, + { + "label": "INTEGER", + "kind": "property", + "documentation": "INTEGER: java.text.NumberFormat$Field", + "insertText": "INTEGER" + }, + { + "label": "PERCENT", + "kind": "property", + "documentation": "PERCENT: java.text.NumberFormat$Field", + "insertText": "PERCENT" + }, + { + "label": "PERMILLE", + "kind": "property", + "documentation": "PERMILLE: java.text.NumberFormat$Field", + "insertText": "PERMILLE" + }, + { + "label": "SIGN", + "kind": "property", + "documentation": "SIGN: java.text.NumberFormat$Field", + "insertText": "SIGN" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ParseException", + "kind": "class", + "documentation": "Class: ParseException", + "insertText": "ParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorOffset", + "kind": "method", + "documentation": "getErrorOffset(): int", + "insertText": "getErrorOffset" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParseException", + "kind": "constructor", + "documentation": "Constructor: ParseException", + "insertText": "ParseException" + } + }, + { + "label": "ParsePosition", + "kind": "class", + "documentation": "Class: ParsePosition", + "insertText": "ParsePosition", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setErrorIndex", + "kind": "method", + "documentation": "setErrorIndex(int a): void", + "insertText": "setErrorIndex" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): void", + "insertText": "setIndex" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ParsePosition", + "kind": "constructor", + "documentation": "Constructor: ParsePosition", + "insertText": "ParsePosition" + } + }, + { + "label": "RuleBasedCollator", + "kind": "class", + "documentation": "Class: RuleBasedCollator", + "insertText": "RuleBasedCollator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.String a, java.lang.String b | java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCollationElementIterator", + "kind": "method", + "documentation": "getCollationElementIterator(java.lang.String a): java.text.CollationElementIterator", + "insertText": "getCollationElementIterator" + }, + { + "label": "getCollationKey", + "kind": "method", + "documentation": "getCollationKey(java.lang.String a): java.text.CollationKey", + "insertText": "getCollationKey" + }, + { + "label": "getDecomposition", + "kind": "method", + "documentation": "getDecomposition(): int", + "insertText": "getDecomposition" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.lang.String", + "insertText": "getRules" + }, + { + "label": "getStrength", + "kind": "method", + "documentation": "getStrength(): int", + "insertText": "getStrength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "setDecomposition", + "kind": "method", + "documentation": "setDecomposition(int a): void", + "insertText": "setDecomposition" + }, + { + "label": "setStrength", + "kind": "method", + "documentation": "setStrength(int a): void", + "insertText": "setStrength" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "RuleBasedCollator", + "kind": "constructor", + "documentation": "Constructor: RuleBasedCollator", + "insertText": "RuleBasedCollator" + } + }, + { + "label": "SimpleDateFormat", + "kind": "class", + "documentation": "Class: SimpleDateFormat", + "insertText": "SimpleDateFormat", + "properties": [ + { + "label": "applyLocalizedPattern", + "kind": "method", + "documentation": "applyLocalizedPattern(java.lang.String a): void", + "insertText": "applyLocalizedPattern" + }, + { + "label": "applyPattern", + "kind": "method", + "documentation": "applyPattern(java.lang.String a): void", + "insertText": "applyPattern" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.lang.Object a, java.lang.StringBuffer b, java.text.FieldPosition c | java.lang.Object a): java.lang.StringBuffer | java.lang.String", + "insertText": "format" + }, + { + "label": "formatToCharacterIterator", + "kind": "method", + "documentation": "formatToCharacterIterator(java.lang.Object a): java.text.AttributedCharacterIterator", + "insertText": "formatToCharacterIterator" + }, + { + "label": "get2DigitYearStart", + "kind": "method", + "documentation": "get2DigitYearStart(): java.util.Date", + "insertText": "get2DigitYearStart" + }, + { + "label": "getCalendar", + "kind": "method", + "documentation": "getCalendar(): java.util.Calendar", + "insertText": "getCalendar" + }, + { + "label": "getDateFormatSymbols", + "kind": "method", + "documentation": "getDateFormatSymbols(): java.text.DateFormatSymbols", + "insertText": "getDateFormatSymbols" + }, + { + "label": "getNumberFormat", + "kind": "method", + "documentation": "getNumberFormat(): java.text.NumberFormat", + "insertText": "getNumberFormat" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.util.Date", + "insertText": "parse" + }, + { + "label": "parseObject", + "kind": "method", + "documentation": "parseObject(java.lang.String a, java.text.ParsePosition b | java.lang.String a): java.lang.Object", + "insertText": "parseObject" + }, + { + "label": "set2DigitYearStart", + "kind": "method", + "documentation": "set2DigitYearStart(java.util.Date a): void", + "insertText": "set2DigitYearStart" + }, + { + "label": "setCalendar", + "kind": "method", + "documentation": "setCalendar(java.util.Calendar a): void", + "insertText": "setCalendar" + }, + { + "label": "setDateFormatSymbols", + "kind": "method", + "documentation": "setDateFormatSymbols(java.text.DateFormatSymbols a): void", + "insertText": "setDateFormatSymbols" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setNumberFormat", + "kind": "method", + "documentation": "setNumberFormat(java.text.NumberFormat a): void", + "insertText": "setNumberFormat" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "toLocalizedPattern", + "kind": "method", + "documentation": "toLocalizedPattern(): java.lang.String", + "insertText": "toLocalizedPattern" + }, + { + "label": "toPattern", + "kind": "method", + "documentation": "toPattern(): java.lang.String", + "insertText": "toPattern" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "SimpleDateFormat", + "kind": "constructor", + "documentation": "Constructor: SimpleDateFormat", + "insertText": "SimpleDateFormat" + } + }, + { + "label": "StringCharacterIterator", + "kind": "class", + "documentation": "Class: StringCharacterIterator", + "insertText": "StringCharacterIterator", + "properties": [ + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "current", + "kind": "method", + "documentation": "current(): char", + "insertText": "current" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): char", + "insertText": "first" + }, + { + "label": "getBeginIndex", + "kind": "method", + "documentation": "getBeginIndex(): int", + "insertText": "getBeginIndex" + }, + { + "label": "getEndIndex", + "kind": "method", + "documentation": "getEndIndex(): int", + "insertText": "getEndIndex" + }, + { + "label": "getIndex", + "kind": "method", + "documentation": "getIndex(): int", + "insertText": "getIndex" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): char", + "insertText": "last" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): char", + "insertText": "next" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(): char", + "insertText": "previous" + }, + { + "label": "setIndex", + "kind": "method", + "documentation": "setIndex(int a): char", + "insertText": "setIndex" + }, + { + "label": "setText", + "kind": "method", + "documentation": "setText(java.lang.String a): void", + "insertText": "setText" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringCharacterIterator", + "kind": "constructor", + "documentation": "Constructor: StringCharacterIterator", + "insertText": "StringCharacterIterator" + } + }, + { + "label": "Clock", + "kind": "class", + "documentation": "Class: Clock", + "insertText": "Clock", + "properties": [ + { + "label": "fixed", + "kind": "method", + "documentation": "fixed(java.time.Instant a, java.time.ZoneId b): java.time.Clock", + "insertText": "fixed" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "offset" + }, + { + "label": "tick", + "kind": "method", + "documentation": "tick(java.time.Clock a, java.time.Duration b): java.time.Clock", + "insertText": "tick" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "instant", + "kind": "method", + "documentation": "instant(): java.time.Instant", + "insertText": "instant" + }, + { + "label": "millis", + "kind": "method", + "documentation": "millis(): long", + "insertText": "millis" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeException", + "kind": "class", + "documentation": "Class: DateTimeException", + "insertText": "DateTimeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeException", + "kind": "constructor", + "documentation": "Constructor: DateTimeException", + "insertText": "DateTimeException" + } + }, + { + "label": "DayOfWeek", + "kind": "class", + "documentation": "Class: DayOfWeek", + "insertText": "DayOfWeek", + "properties": [ + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: java.time.DayOfWeek", + "insertText": "FRIDAY" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: java.time.DayOfWeek", + "insertText": "MONDAY" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: java.time.DayOfWeek", + "insertText": "SATURDAY" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: java.time.DayOfWeek", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: java.time.DayOfWeek", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: java.time.DayOfWeek", + "insertText": "TUESDAY" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: java.time.DayOfWeek", + "insertText": "WEDNESDAY" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.DayOfWeek", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.DayOfWeek", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.DayOfWeek", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.DayOfWeek;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.DayOfWeek", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.DayOfWeek", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Duration", + "kind": "class", + "documentation": "Class: Duration", + "insertText": "Duration", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Duration", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): java.time.Duration", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Duration", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a, java.time.temporal.TemporalUnit b): java.time.Duration", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(long a): java.time.Duration", + "insertText": "ofDays" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(long a): java.time.Duration", + "insertText": "ofHours" + }, + { + "label": "ofMillis", + "kind": "method", + "documentation": "ofMillis(long a): java.time.Duration", + "insertText": "ofMillis" + }, + { + "label": "ofMinutes", + "kind": "method", + "documentation": "ofMinutes(long a): java.time.Duration", + "insertText": "ofMinutes" + }, + { + "label": "ofNanos", + "kind": "method", + "documentation": "ofNanos(long a): java.time.Duration", + "insertText": "ofNanos" + }, + { + "label": "ofSeconds", + "kind": "method", + "documentation": "ofSeconds(long a, long b | long a): java.time.Duration", + "insertText": "ofSeconds" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Duration", + "insertText": "parse" + }, + { + "label": "abs", + "kind": "method", + "documentation": "abs(): java.time.Duration", + "insertText": "abs" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Duration a): int", + "insertText": "compareTo" + }, + { + "label": "dividedBy", + "kind": "method", + "documentation": "dividedBy(long a): java.time.Duration", + "insertText": "dividedBy" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSeconds", + "kind": "method", + "documentation": "getSeconds(): long", + "insertText": "getSeconds" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Duration", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.Duration", + "insertText": "minusHours" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Duration", + "insertText": "minusMillis" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.Duration", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Duration", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Duration", + "insertText": "minusSeconds" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(long a): java.time.Duration", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Duration", + "insertText": "negated" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.Duration a): java.time.Duration", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Duration", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.Duration", + "insertText": "plusHours" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Duration", + "insertText": "plusMillis" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.Duration", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Duration", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Duration", + "insertText": "plusSeconds" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toDays", + "kind": "method", + "documentation": "toDays(): long", + "insertText": "toDays" + }, + { + "label": "toHours", + "kind": "method", + "documentation": "toHours(): long", + "insertText": "toHours" + }, + { + "label": "toMillis", + "kind": "method", + "documentation": "toMillis(): long", + "insertText": "toMillis" + }, + { + "label": "toMinutes", + "kind": "method", + "documentation": "toMinutes(): long", + "insertText": "toMinutes" + }, + { + "label": "toNanos", + "kind": "method", + "documentation": "toNanos(): long", + "insertText": "toNanos" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withNanos", + "kind": "method", + "documentation": "withNanos(int a): java.time.Duration", + "insertText": "withNanos" + }, + { + "label": "withSeconds", + "kind": "method", + "documentation": "withSeconds(long a): java.time.Duration", + "insertText": "withSeconds" + } + ] + }, + { + "label": "Instant", + "kind": "class", + "documentation": "Class: Instant", + "insertText": "Instant", + "properties": [ + { + "label": "EPOCH", + "kind": "property", + "documentation": "EPOCH: java.time.Instant", + "insertText": "EPOCH" + }, + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.Instant", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.Instant", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Instant", + "insertText": "from" + }, + { + "label": "ofEpochMilli", + "kind": "method", + "documentation": "ofEpochMilli(long a): java.time.Instant", + "insertText": "ofEpochMilli" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, long b | long a): java.time.Instant", + "insertText": "ofEpochSecond" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Instant", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Instant a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getEpochSecond", + "kind": "method", + "documentation": "getEpochSecond(): long", + "insertText": "getEpochSecond" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Instant a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.Instant a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "minus" + }, + { + "label": "minusMillis", + "kind": "method", + "documentation": "minusMillis(long a): java.time.Instant", + "insertText": "minusMillis" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.Instant", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.Instant", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Instant", + "insertText": "plus" + }, + { + "label": "plusMillis", + "kind": "method", + "documentation": "plusMillis(long a): java.time.Instant", + "insertText": "plusMillis" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.Instant", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.Instant", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.Instant", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Instant", + "insertText": "with" + } + ] + }, + { + "label": "LocalDate", + "kind": "class", + "documentation": "Class: LocalDate", + "insertText": "LocalDate", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDate", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDate", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.LocalDate", + "insertText": "of" + }, + { + "label": "ofEpochDay", + "kind": "method", + "documentation": "ofEpochDay(long a): java.time.LocalDate", + "insertText": "ofEpochDay" + }, + { + "label": "ofYearDay", + "kind": "method", + "documentation": "ofYearDay(int a, int b): java.time.LocalDate", + "insertText": "ofYearDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDate", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atStartOfDay", + "kind": "method", + "documentation": "atStartOfDay(java.time.ZoneId a): java.time.ZonedDateTime | java.time.LocalDateTime", + "insertText": "atStartOfDay" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(int a, int b, int c, int d | int a, int b, int c | int a, int b | java.time.LocalTime a): java.time.LocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDate", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDate", + "insertText": "minusMonths" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDate", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDate", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDate", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDate", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDate", + "insertText": "plusMonths" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDate", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDate", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.Period", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDate", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDate", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDate", + "insertText": "withDayOfYear" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDate", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDate", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalDateTime", + "kind": "class", + "documentation": "Class: LocalDateTime", + "insertText": "LocalDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined | int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | java.time.LocalDate a, java.time.LocalTime b): java.time.LocalDateTime", + "insertText": "of" + }, + { + "label": "ofEpochSecond", + "kind": "method", + "documentation": "ofEpochSecond(long a, int b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "ofEpochSecond" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.LocalDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalDateTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "atOffset" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.LocalDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.LocalDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.LocalDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.LocalDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.LocalDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.LocalDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.LocalDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.LocalDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.LocalDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.LocalDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.LocalDateTime", + "insertText": "withMonth" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.LocalDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "LocalTime", + "kind": "class", + "documentation": "Class: LocalTime", + "insertText": "LocalTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.LocalTime", + "insertText": "MAX" + }, + { + "label": "MIDNIGHT", + "kind": "property", + "documentation": "MIDNIGHT: java.time.LocalTime", + "insertText": "MIDNIGHT" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.LocalTime", + "insertText": "MIN" + }, + { + "label": "NOON", + "kind": "property", + "documentation": "NOON: java.time.LocalTime", + "insertText": "NOON" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.LocalTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d | int a, int b, int c | int a, int b): java.time.LocalTime", + "insertText": "of" + }, + { + "label": "ofNanoOfDay", + "kind": "method", + "documentation": "ofNanoOfDay(long a): java.time.LocalTime", + "insertText": "ofNanoOfDay" + }, + { + "label": "ofSecondOfDay", + "kind": "method", + "documentation": "ofSecondOfDay(long a): java.time.LocalTime", + "insertText": "ofSecondOfDay" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.LocalTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDate", + "kind": "method", + "documentation": "atDate(java.time.LocalDate a): java.time.LocalDateTime", + "insertText": "atDate" + }, + { + "label": "atOffset", + "kind": "method", + "documentation": "atOffset(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "atOffset" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.LocalTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.LocalTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.LocalTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.LocalTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.LocalTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.LocalTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.LocalTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.LocalTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.LocalTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.LocalTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.LocalTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.LocalTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toNanoOfDay", + "kind": "method", + "documentation": "toNanoOfDay(): long", + "insertText": "toNanoOfDay" + }, + { + "label": "toSecondOfDay", + "kind": "method", + "documentation": "toSecondOfDay(): int", + "insertText": "toSecondOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.LocalTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.LocalTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.LocalTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.LocalTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.LocalTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.LocalTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Month", + "kind": "class", + "documentation": "Class: Month", + "insertText": "Month", + "properties": [ + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: java.time.Month", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: java.time.Month", + "insertText": "AUGUST" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: java.time.Month", + "insertText": "DECEMBER" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: java.time.Month", + "insertText": "FEBRUARY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: java.time.Month", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: java.time.Month", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: java.time.Month", + "insertText": "JUNE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: java.time.Month", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: java.time.Month", + "insertText": "MAY" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: java.time.Month", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: java.time.Month", + "insertText": "OCTOBER" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: java.time.Month", + "insertText": "SEPTEMBER" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Month", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Month", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.Month", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.Month;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(boolean a): int", + "insertText": "firstDayOfYear" + }, + { + "label": "firstMonthOfQuarter", + "kind": "method", + "documentation": "firstMonthOfQuarter(): java.time.Month", + "insertText": "firstMonthOfQuarter" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(boolean a): int", + "insertText": "length" + }, + { + "label": "maxLength", + "kind": "method", + "documentation": "maxLength(): int", + "insertText": "maxLength" + }, + { + "label": "minLength", + "kind": "method", + "documentation": "minLength(): int", + "insertText": "minLength" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a): java.time.Month", + "insertText": "minus" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a): java.time.Month", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MonthDay", + "kind": "class", + "documentation": "Class: MonthDay", + "insertText": "MonthDay", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.MonthDay", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.MonthDay", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.MonthDay", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atYear", + "kind": "method", + "documentation": "atYear(int a): java.time.LocalDate", + "insertText": "atYear" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.MonthDay a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.MonthDay a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.MonthDay a): boolean", + "insertText": "isBefore" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidYear", + "kind": "method", + "documentation": "isValidYear(int a): boolean", + "insertText": "isValidYear" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.Month a): java.time.MonthDay", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.MonthDay", + "insertText": "withDayOfMonth" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.MonthDay", + "insertText": "withMonth" + } + ] + }, + { + "label": "OffsetDateTime", + "kind": "class", + "documentation": "Class: OffsetDateTime", + "insertText": "OffsetDateTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetDateTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetDateTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneOffset undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneOffset c | java.time.LocalDateTime a, java.time.ZoneOffset b): java.time.OffsetDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetDateTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetDateTime", + "insertText": "parse" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZoneSameInstant", + "kind": "method", + "documentation": "atZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSameInstant" + }, + { + "label": "atZoneSimilarLocal", + "kind": "method", + "documentation": "atZoneSimilarLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "atZoneSimilarLocal" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.OffsetDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.OffsetDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.OffsetDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.OffsetDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.OffsetDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.OffsetDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.OffsetDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.OffsetDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetTime", + "kind": "method", + "documentation": "toOffsetTime(): java.time.OffsetTime", + "insertText": "toOffsetTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.OffsetDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.OffsetDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetDateTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.OffsetDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetDateTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetDateTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.OffsetDateTime", + "insertText": "withYear" + } + ] + }, + { + "label": "OffsetTime", + "kind": "class", + "documentation": "Class: OffsetTime", + "insertText": "OffsetTime", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.OffsetTime", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.OffsetTime", + "insertText": "MIN" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.OffsetTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, java.time.ZoneOffset e | java.time.LocalTime a, java.time.ZoneOffset b): java.time.OffsetTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.Instant a, java.time.ZoneId b): java.time.OffsetTime", + "insertText": "ofInstant" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.OffsetTime", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.OffsetTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.OffsetTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.OffsetTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.OffsetTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "minus" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.OffsetTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.OffsetTime", + "insertText": "minusMinutes" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.OffsetTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.OffsetTime", + "insertText": "minusSeconds" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.OffsetTime", + "insertText": "plus" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.OffsetTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.OffsetTime", + "insertText": "plusMinutes" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.OffsetTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.OffsetTime", + "insertText": "plusSeconds" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.OffsetTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.OffsetTime", + "insertText": "with" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.OffsetTime", + "insertText": "withHour" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.OffsetTime", + "insertText": "withMinute" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.OffsetTime", + "insertText": "withNano" + }, + { + "label": "withOffsetSameInstant", + "kind": "method", + "documentation": "withOffsetSameInstant(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameInstant" + }, + { + "label": "withOffsetSameLocal", + "kind": "method", + "documentation": "withOffsetSameLocal(java.time.ZoneOffset a): java.time.OffsetTime", + "insertText": "withOffsetSameLocal" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.OffsetTime", + "insertText": "withSecond" + } + ] + }, + { + "label": "Period", + "kind": "class", + "documentation": "Class: Period", + "insertText": "Period", + "properties": [ + { + "label": "ZERO", + "kind": "property", + "documentation": "ZERO: java.time.Period", + "insertText": "ZERO" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.LocalDate a, java.time.LocalDate b): java.time.Period", + "insertText": "between" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.Period", + "insertText": "of" + }, + { + "label": "ofDays", + "kind": "method", + "documentation": "ofDays(int a): java.time.Period", + "insertText": "ofDays" + }, + { + "label": "ofMonths", + "kind": "method", + "documentation": "ofMonths(int a): java.time.Period", + "insertText": "ofMonths" + }, + { + "label": "ofWeeks", + "kind": "method", + "documentation": "ofWeeks(int a): java.time.Period", + "insertText": "ofWeeks" + }, + { + "label": "ofYears", + "kind": "method", + "documentation": "ofYears(int a): java.time.Period", + "insertText": "ofYears" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a): java.time.Period", + "insertText": "parse" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.IsoChronology", + "insertText": "getChronology" + }, + { + "label": "getDays", + "kind": "method", + "documentation": "getDays(): int", + "insertText": "getDays" + }, + { + "label": "getMonths", + "kind": "method", + "documentation": "getMonths(): int", + "insertText": "getMonths" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "getYears", + "kind": "method", + "documentation": "getYears(): int", + "insertText": "getYears" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.Period", + "insertText": "minusDays" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.Period", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Period", + "insertText": "minusYears" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.Period", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.Period", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.Period", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.Period", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.Period", + "insertText": "plusDays" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.Period", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Period", + "insertText": "plusYears" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toTotalMonths", + "kind": "method", + "documentation": "toTotalMonths(): long", + "insertText": "toTotalMonths" + }, + { + "label": "withDays", + "kind": "method", + "documentation": "withDays(int a): java.time.Period", + "insertText": "withDays" + }, + { + "label": "withMonths", + "kind": "method", + "documentation": "withMonths(int a): java.time.Period", + "insertText": "withMonths" + }, + { + "label": "withYears", + "kind": "method", + "documentation": "withYears(int a): java.time.Period", + "insertText": "withYears" + } + ] + }, + { + "label": "Year", + "kind": "class", + "documentation": "Class: Year", + "insertText": "Year", + "properties": [ + { + "label": "MAX_VALUE", + "kind": "property", + "documentation": "MAX_VALUE: int", + "insertText": "MAX_VALUE" + }, + { + "label": "MIN_VALUE", + "kind": "property", + "documentation": "MIN_VALUE: int", + "insertText": "MIN_VALUE" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.Year", + "insertText": "from" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(long a): boolean", + "insertText": "isLeap" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.Year", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.Year", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atMonth", + "kind": "method", + "documentation": "atMonth(int a): java.time.YearMonth", + "insertText": "atMonth" + }, + { + "label": "atMonthDay", + "kind": "method", + "documentation": "atMonthDay(java.time.MonthDay a): java.time.LocalDate", + "insertText": "atMonthDay" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.Year a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.Year a): boolean", + "insertText": "isAfter" + }, + { + "label": "isLeap", + "kind": "method", + "documentation": "isLeap(): boolean", + "insertText": "isLeap" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidMonthDay", + "kind": "method", + "documentation": "isValidMonthDay(java.time.MonthDay a): boolean", + "insertText": "isValidMonthDay" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "minus" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.Year", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.Year", + "insertText": "plus" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.Year", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.Year", + "insertText": "with" + } + ] + }, + { + "label": "YearMonth", + "kind": "class", + "documentation": "Class: YearMonth", + "insertText": "YearMonth", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.YearMonth", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b): java.time.YearMonth", + "insertText": "of" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.YearMonth", + "insertText": "parse" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atDay", + "kind": "method", + "documentation": "atDay(int a): java.time.LocalDate", + "insertText": "atDay" + }, + { + "label": "atEndOfMonth", + "kind": "method", + "documentation": "atEndOfMonth(): java.time.LocalDate", + "insertText": "atEndOfMonth" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.YearMonth a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.YearMonth a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.YearMonth a): boolean", + "insertText": "isBefore" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "isValidDay", + "kind": "method", + "documentation": "isValidDay(int a): boolean", + "insertText": "isValidDay" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "minus" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.YearMonth", + "insertText": "minusMonths" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.YearMonth", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.YearMonth", + "insertText": "plus" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.YearMonth", + "insertText": "plusMonths" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.YearMonth", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.YearMonth", + "insertText": "with" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.YearMonth", + "insertText": "withMonth" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.YearMonth", + "insertText": "withYear" + } + ] + }, + { + "label": "ZoneId", + "kind": "class", + "documentation": "Class: ZoneId", + "insertText": "ZoneId", + "properties": [ + { + "label": "SHORT_IDS", + "kind": "property", + "documentation": "SHORT_IDS: java.util.Map", + "insertText": "SHORT_IDS" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneId", + "insertText": "from" + }, + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a, java.util.Map b | java.lang.String a): java.time.ZoneId", + "insertText": "of" + }, + { + "label": "ofOffset", + "kind": "method", + "documentation": "ofOffset(java.lang.String a, java.time.ZoneOffset b): java.time.ZoneId", + "insertText": "ofOffset" + }, + { + "label": "systemDefault", + "kind": "method", + "documentation": "systemDefault(): java.time.ZoneId", + "insertText": "systemDefault" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffset", + "kind": "class", + "documentation": "Class: ZoneOffset", + "insertText": "ZoneOffset", + "properties": [ + { + "label": "MAX", + "kind": "property", + "documentation": "MAX: java.time.ZoneOffset", + "insertText": "MAX" + }, + { + "label": "MIN", + "kind": "property", + "documentation": "MIN: java.time.ZoneOffset", + "insertText": "MIN" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.ZoneOffset", + "insertText": "UTC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZoneOffset", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.ZoneOffset", + "insertText": "of" + }, + { + "label": "ofHours", + "kind": "method", + "documentation": "ofHours(int a): java.time.ZoneOffset", + "insertText": "ofHours" + }, + { + "label": "ofHoursMinutes", + "kind": "method", + "documentation": "ofHoursMinutes(int a, int b): java.time.ZoneOffset", + "insertText": "ofHoursMinutes" + }, + { + "label": "ofHoursMinutesSeconds", + "kind": "method", + "documentation": "ofHoursMinutesSeconds(int a, int b, int c): java.time.ZoneOffset", + "insertText": "ofHoursMinutesSeconds" + }, + { + "label": "ofTotalSeconds", + "kind": "method", + "documentation": "ofTotalSeconds(int a): java.time.ZoneOffset", + "insertText": "ofTotalSeconds" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getTotalSeconds", + "kind": "method", + "documentation": "getTotalSeconds(): int", + "insertText": "getTotalSeconds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.ZoneId", + "insertText": "normalized" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZonedDateTime", + "kind": "class", + "documentation": "Class: ZonedDateTime", + "insertText": "ZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c, int d, int e, int f, int undefined, java.time.ZoneId undefined | java.time.LocalDate a, java.time.LocalTime b, java.time.ZoneId c | java.time.LocalDateTime a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "of" + }, + { + "label": "ofInstant", + "kind": "method", + "documentation": "ofInstant(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c | java.time.Instant a, java.time.ZoneId b): java.time.ZonedDateTime", + "insertText": "ofInstant" + }, + { + "label": "ofLocal", + "kind": "method", + "documentation": "ofLocal(java.time.LocalDateTime a, java.time.ZoneId b, java.time.ZoneOffset c): java.time.ZonedDateTime", + "insertText": "ofLocal" + }, + { + "label": "ofStrict", + "kind": "method", + "documentation": "ofStrict(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneId c): java.time.ZonedDateTime", + "insertText": "ofStrict" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.format.DateTimeFormatter b | java.lang.CharSequence a): java.time.ZonedDateTime", + "insertText": "parse" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "AbstractChronology", + "kind": "class", + "documentation": "Class: AbstractChronology", + "insertText": "AbstractChronology", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ChronoLocalDate", + "kind": "class", + "documentation": "Class: ChronoLocalDate", + "insertText": "ChronoLocalDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.Era", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDate", + "insertText": "with" + } + ] + }, + { + "label": "ChronoLocalDateTime", + "kind": "class", + "documentation": "Class: ChronoLocalDateTime", + "insertText": "ChronoLocalDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atZone", + "kind": "method", + "documentation": "atZone(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "atZone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoLocalDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(java.time.ZoneOffset a): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(java.time.ZoneOffset a): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoLocalDateTime", + "insertText": "with" + } + ] + }, + { + "label": "ChronoPeriod", + "kind": "class", + "documentation": "Class: ChronoPeriod", + "insertText": "ChronoPeriod", + "properties": [ + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.chrono.ChronoLocalDate a, java.time.chrono.ChronoLocalDate b): java.time.chrono.ChronoPeriod", + "insertText": "between" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isNegative", + "kind": "method", + "documentation": "isNegative(): boolean", + "insertText": "isNegative" + }, + { + "label": "isZero", + "kind": "method", + "documentation": "isZero(): boolean", + "insertText": "isZero" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "minus" + }, + { + "label": "multipliedBy", + "kind": "method", + "documentation": "multipliedBy(int a): java.time.chrono.ChronoPeriod", + "insertText": "multipliedBy" + }, + { + "label": "negated", + "kind": "method", + "documentation": "negated(): java.time.chrono.ChronoPeriod", + "insertText": "negated" + }, + { + "label": "normalized", + "kind": "method", + "documentation": "normalized(): java.time.chrono.ChronoPeriod", + "insertText": "normalized" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(java.time.temporal.TemporalAmount a): java.time.chrono.ChronoPeriod", + "insertText": "plus" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoZonedDateTime", + "kind": "class", + "documentation": "Class: ChronoZonedDateTime", + "insertText": "ChronoZonedDateTime", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "from" + }, + { + "label": "timeLineOrder", + "kind": "method", + "documentation": "timeLineOrder(): java.util.Comparator", + "insertText": "timeLineOrder" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ChronoZonedDateTime", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.chrono.ChronoLocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.chrono.ChronoLocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ChronoZonedDateTime", + "insertText": "with" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.chrono.ChronoZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.chrono.ChronoZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "Chronology", + "kind": "class", + "documentation": "Class: Chronology", + "insertText": "Chronology", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.Chronology", + "insertText": "from" + }, + { + "label": "getAvailableChronologies", + "kind": "method", + "documentation": "getAvailableChronologies(): java.util.Set", + "insertText": "getAvailableChronologies" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.lang.String a): java.time.chrono.Chronology", + "insertText": "of" + }, + { + "label": "ofLocale", + "kind": "method", + "documentation": "ofLocale(java.util.Locale a): java.time.chrono.Chronology", + "insertText": "ofLocale" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ChronoLocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ChronoLocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.Era", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ChronoLocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "Era", + "kind": "class", + "documentation": "Class: Era", + "insertText": "Era", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "HijrahChronology", + "kind": "class", + "documentation": "Class: HijrahChronology", + "insertText": "HijrahChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.HijrahChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.HijrahDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.HijrahDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.HijrahEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.HijrahDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "HijrahDate", + "kind": "class", + "documentation": "Class: HijrahDate", + "insertText": "HijrahDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.HijrahDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.HijrahDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.HijrahChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.HijrahEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.HijrahDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.HijrahDate", + "insertText": "with" + }, + { + "label": "withVariant", + "kind": "method", + "documentation": "withVariant(java.time.chrono.HijrahChronology a): java.time.chrono.HijrahDate", + "insertText": "withVariant" + } + ] + }, + { + "label": "HijrahEra", + "kind": "class", + "documentation": "Class: HijrahEra", + "insertText": "HijrahEra", + "properties": [ + { + "label": "AH", + "kind": "property", + "documentation": "AH: java.time.chrono.HijrahEra", + "insertText": "AH" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.HijrahEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.HijrahEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.HijrahEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoChronology", + "kind": "class", + "documentation": "Class: IsoChronology", + "insertText": "IsoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.IsoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.LocalDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.LocalDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.LocalDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.IsoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.LocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.Period", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.LocalDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.ZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "IsoEra", + "kind": "class", + "documentation": "Class: IsoEra", + "insertText": "IsoEra", + "properties": [ + { + "label": "BCE", + "kind": "property", + "documentation": "BCE: java.time.chrono.IsoEra", + "insertText": "BCE" + }, + { + "label": "CE", + "kind": "property", + "documentation": "CE: java.time.chrono.IsoEra", + "insertText": "CE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.IsoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.IsoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.IsoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JapaneseChronology", + "kind": "class", + "documentation": "Class: JapaneseChronology", + "insertText": "JapaneseChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.JapaneseChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.JapaneseDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.JapaneseDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.JapaneseEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.JapaneseDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "JapaneseDate", + "kind": "class", + "documentation": "Class: JapaneseDate", + "insertText": "JapaneseDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.JapaneseDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.JapaneseDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.JapaneseChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.JapaneseEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.JapaneseDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.JapaneseDate", + "insertText": "with" + } + ] + }, + { + "label": "JapaneseEra", + "kind": "class", + "documentation": "Class: JapaneseEra", + "insertText": "JapaneseEra", + "properties": [ + { + "label": "HEISEI", + "kind": "property", + "documentation": "HEISEI: java.time.chrono.JapaneseEra", + "insertText": "HEISEI" + }, + { + "label": "MEIJI", + "kind": "property", + "documentation": "MEIJI: java.time.chrono.JapaneseEra", + "insertText": "MEIJI" + }, + { + "label": "SHOWA", + "kind": "property", + "documentation": "SHOWA: java.time.chrono.JapaneseEra", + "insertText": "SHOWA" + }, + { + "label": "TAISHO", + "kind": "property", + "documentation": "TAISHO: java.time.chrono.JapaneseEra", + "insertText": "TAISHO" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.JapaneseEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.JapaneseEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.JapaneseEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MinguoChronology", + "kind": "class", + "documentation": "Class: MinguoChronology", + "insertText": "MinguoChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.MinguoChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.MinguoDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.MinguoDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.MinguoEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.MinguoDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "MinguoDate", + "kind": "class", + "documentation": "Class: MinguoDate", + "insertText": "MinguoDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.MinguoDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.MinguoDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.MinguoChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.MinguoEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.MinguoDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.MinguoDate", + "insertText": "with" + } + ] + }, + { + "label": "MinguoEra", + "kind": "class", + "documentation": "Class: MinguoEra", + "insertText": "MinguoEra", + "properties": [ + { + "label": "BEFORE_ROC", + "kind": "property", + "documentation": "BEFORE_ROC: java.time.chrono.MinguoEra", + "insertText": "BEFORE_ROC" + }, + { + "label": "ROC", + "kind": "property", + "documentation": "ROC: java.time.chrono.MinguoEra", + "insertText": "ROC" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.MinguoEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.MinguoEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.MinguoEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ThaiBuddhistChronology", + "kind": "class", + "documentation": "Class: ThaiBuddhistChronology", + "insertText": "ThaiBuddhistChronology", + "properties": [ + { + "label": "INSTANCE", + "kind": "property", + "documentation": "INSTANCE: java.time.chrono.ThaiBuddhistChronology", + "insertText": "INSTANCE" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.Chronology a): int", + "insertText": "compareTo" + }, + { + "label": "date", + "kind": "method", + "documentation": "date(java.time.chrono.Era a, int b, int c, int d | int a, int b, int c | java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "date" + }, + { + "label": "dateEpochDay", + "kind": "method", + "documentation": "dateEpochDay(long a): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateEpochDay" + }, + { + "label": "dateYearDay", + "kind": "method", + "documentation": "dateYearDay(java.time.chrono.Era a, int b, int c | int a, int b): java.time.chrono.ThaiBuddhistDate", + "insertText": "dateYearDay" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "eraOf", + "kind": "method", + "documentation": "eraOf(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "eraOf" + }, + { + "label": "eras", + "kind": "method", + "documentation": "eras(): java.util.List", + "insertText": "eras" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getId", + "kind": "method", + "documentation": "getId(): java.lang.String", + "insertText": "getId" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(long a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "localDateTime", + "kind": "method", + "documentation": "localDateTime(java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoLocalDateTime", + "insertText": "localDateTime" + }, + { + "label": "period", + "kind": "method", + "documentation": "period(int a, int b, int c): java.time.chrono.ChronoPeriod", + "insertText": "period" + }, + { + "label": "prolepticYear", + "kind": "method", + "documentation": "prolepticYear(java.time.chrono.Era a, int b): int", + "insertText": "prolepticYear" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.ChronoField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "resolveDate", + "kind": "method", + "documentation": "resolveDate(java.util.Map a, java.time.format.ResolverStyle b): java.time.chrono.ThaiBuddhistDate", + "insertText": "resolveDate" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "zonedDateTime", + "kind": "method", + "documentation": "zonedDateTime(java.time.Instant a, java.time.ZoneId b | java.time.temporal.TemporalAccessor a): java.time.chrono.ChronoZonedDateTime", + "insertText": "zonedDateTime" + } + ] + }, + { + "label": "ThaiBuddhistDate", + "kind": "class", + "documentation": "Class: ThaiBuddhistDate", + "insertText": "ThaiBuddhistDate", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.temporal.TemporalAccessor a): java.time.chrono.ThaiBuddhistDate", + "insertText": "from" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a, int b, int c): java.time.chrono.ThaiBuddhistDate", + "insertText": "of" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "atTime", + "kind": "method", + "documentation": "atTime(java.time.LocalTime a): java.time.chrono.ChronoLocalDateTime", + "insertText": "atTime" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoLocalDate a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.ThaiBuddhistChronology", + "insertText": "getChronology" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): java.time.chrono.ThaiBuddhistEra", + "insertText": "getEra" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoLocalDate a): boolean", + "insertText": "isEqual" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "lengthOfMonth", + "kind": "method", + "documentation": "lengthOfMonth(): int", + "insertText": "lengthOfMonth" + }, + { + "label": "lengthOfYear", + "kind": "method", + "documentation": "lengthOfYear(): int", + "insertText": "lengthOfYear" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.chrono.ThaiBuddhistDate", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochDay", + "kind": "method", + "documentation": "toEpochDay(): long", + "insertText": "toEpochDay" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b | java.time.chrono.ChronoLocalDate a): long | java.time.chrono.ChronoPeriod", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.chrono.ThaiBuddhistDate", + "insertText": "with" + } + ] + }, + { + "label": "ThaiBuddhistEra", + "kind": "class", + "documentation": "Class: ThaiBuddhistEra", + "insertText": "ThaiBuddhistEra", + "properties": [ + { + "label": "BE", + "kind": "property", + "documentation": "BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BE" + }, + { + "label": "BEFORE_BE", + "kind": "property", + "documentation": "BEFORE_BE: java.time.chrono.ThaiBuddhistEra", + "insertText": "BEFORE_BE" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.time.chrono.ThaiBuddhistEra", + "insertText": "of" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.chrono.ThaiBuddhistEra", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.chrono.ThaiBuddhistEra;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.time.format.TextStyle a, java.util.Locale b): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): int", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DateTimeFormatter", + "kind": "class", + "documentation": "Class: DateTimeFormatter", + "insertText": "DateTimeFormatter", + "properties": [ + { + "label": "BASIC_ISO_DATE", + "kind": "property", + "documentation": "BASIC_ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "BASIC_ISO_DATE" + }, + { + "label": "ISO_DATE", + "kind": "property", + "documentation": "ISO_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE" + }, + { + "label": "ISO_DATE_TIME", + "kind": "property", + "documentation": "ISO_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_DATE_TIME" + }, + { + "label": "ISO_INSTANT", + "kind": "property", + "documentation": "ISO_INSTANT: java.time.format.DateTimeFormatter", + "insertText": "ISO_INSTANT" + }, + { + "label": "ISO_LOCAL_DATE", + "kind": "property", + "documentation": "ISO_LOCAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE" + }, + { + "label": "ISO_LOCAL_DATE_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_DATE_TIME" + }, + { + "label": "ISO_LOCAL_TIME", + "kind": "property", + "documentation": "ISO_LOCAL_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_LOCAL_TIME" + }, + { + "label": "ISO_OFFSET_DATE", + "kind": "property", + "documentation": "ISO_OFFSET_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE" + }, + { + "label": "ISO_OFFSET_DATE_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_DATE_TIME" + }, + { + "label": "ISO_OFFSET_TIME", + "kind": "property", + "documentation": "ISO_OFFSET_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_OFFSET_TIME" + }, + { + "label": "ISO_ORDINAL_DATE", + "kind": "property", + "documentation": "ISO_ORDINAL_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_ORDINAL_DATE" + }, + { + "label": "ISO_TIME", + "kind": "property", + "documentation": "ISO_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_TIME" + }, + { + "label": "ISO_WEEK_DATE", + "kind": "property", + "documentation": "ISO_WEEK_DATE: java.time.format.DateTimeFormatter", + "insertText": "ISO_WEEK_DATE" + }, + { + "label": "ISO_ZONED_DATE_TIME", + "kind": "property", + "documentation": "ISO_ZONED_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "ISO_ZONED_DATE_TIME" + }, + { + "label": "RFC_1123_DATE_TIME", + "kind": "property", + "documentation": "RFC_1123_DATE_TIME: java.time.format.DateTimeFormatter", + "insertText": "RFC_1123_DATE_TIME" + }, + { + "label": "ofLocalizedDate", + "kind": "method", + "documentation": "ofLocalizedDate(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDate" + }, + { + "label": "ofLocalizedDateTime", + "kind": "method", + "documentation": "ofLocalizedDateTime(java.time.format.FormatStyle a, java.time.format.FormatStyle b | java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedDateTime" + }, + { + "label": "ofLocalizedTime", + "kind": "method", + "documentation": "ofLocalizedTime(java.time.format.FormatStyle a): java.time.format.DateTimeFormatter", + "insertText": "ofLocalizedTime" + }, + { + "label": "ofPattern", + "kind": "method", + "documentation": "ofPattern(java.lang.String a, java.util.Locale b | java.lang.String a): java.time.format.DateTimeFormatter", + "insertText": "ofPattern" + }, + { + "label": "parsedExcessDays", + "kind": "method", + "documentation": "parsedExcessDays(): java.time.temporal.TemporalQuery", + "insertText": "parsedExcessDays" + }, + { + "label": "parsedLeapSecond", + "kind": "method", + "documentation": "parsedLeapSecond(): java.time.temporal.TemporalQuery", + "insertText": "parsedLeapSecond" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.temporal.TemporalAccessor a): java.lang.String", + "insertText": "format" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.time.temporal.TemporalAccessor a, java.lang.Appendable b): void", + "insertText": "formatTo" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDecimalStyle", + "kind": "method", + "documentation": "getDecimalStyle(): java.time.format.DecimalStyle", + "insertText": "getDecimalStyle" + }, + { + "label": "getLocale", + "kind": "method", + "documentation": "getLocale(): java.util.Locale", + "insertText": "getLocale" + }, + { + "label": "getResolverFields", + "kind": "method", + "documentation": "getResolverFields(): java.util.Set", + "insertText": "getResolverFields" + }, + { + "label": "getResolverStyle", + "kind": "method", + "documentation": "getResolverStyle(): java.time.format.ResolverStyle", + "insertText": "getResolverStyle" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.CharSequence a, java.time.temporal.TemporalQuery b | java.lang.CharSequence a): org.elasticsearch.painless.lookup.def | java.time.temporal.TemporalAccessor", + "insertText": "parse" + }, + { + "label": "parseBest", + "kind": "method", + "documentation": "parseBest(java.lang.CharSequence a, [Ljava.time.temporal.TemporalQuery; b): java.time.temporal.TemporalAccessor", + "insertText": "parseBest" + }, + { + "label": "parseUnresolved", + "kind": "method", + "documentation": "parseUnresolved(java.lang.CharSequence a, java.text.ParsePosition b): java.time.temporal.TemporalAccessor", + "insertText": "parseUnresolved" + }, + { + "label": "toFormat", + "kind": "method", + "documentation": "toFormat(java.time.temporal.TemporalQuery a): java.text.Format", + "insertText": "toFormat" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withChronology", + "kind": "method", + "documentation": "withChronology(java.time.chrono.Chronology a): java.time.format.DateTimeFormatter", + "insertText": "withChronology" + }, + { + "label": "withDecimalStyle", + "kind": "method", + "documentation": "withDecimalStyle(java.time.format.DecimalStyle a): java.time.format.DateTimeFormatter", + "insertText": "withDecimalStyle" + }, + { + "label": "withLocale", + "kind": "method", + "documentation": "withLocale(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "withLocale" + }, + { + "label": "withResolverFields", + "kind": "method", + "documentation": "withResolverFields(java.util.Set a): java.time.format.DateTimeFormatter", + "insertText": "withResolverFields" + }, + { + "label": "withResolverStyle", + "kind": "method", + "documentation": "withResolverStyle(java.time.format.ResolverStyle a): java.time.format.DateTimeFormatter", + "insertText": "withResolverStyle" + }, + { + "label": "withZone", + "kind": "method", + "documentation": "withZone(java.time.ZoneId a): java.time.format.DateTimeFormatter", + "insertText": "withZone" + } + ] + }, + { + "label": "DateTimeFormatterBuilder", + "kind": "class", + "documentation": "Class: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder", + "properties": [ + { + "label": "getLocalizedDateTimePattern", + "kind": "method", + "documentation": "getLocalizedDateTimePattern(java.time.format.FormatStyle a, java.time.format.FormatStyle b, java.time.chrono.Chronology c, java.util.Locale d): java.lang.String", + "insertText": "getLocalizedDateTimePattern" + }, + { + "label": "append", + "kind": "method", + "documentation": "append(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "append" + }, + { + "label": "appendChronologyId", + "kind": "method", + "documentation": "appendChronologyId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyId" + }, + { + "label": "appendChronologyText", + "kind": "method", + "documentation": "appendChronologyText(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendChronologyText" + }, + { + "label": "appendFraction", + "kind": "method", + "documentation": "appendFraction(java.time.temporal.TemporalField a, int b, int c, boolean d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendFraction" + }, + { + "label": "appendInstant", + "kind": "method", + "documentation": "appendInstant(int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendInstant" + }, + { + "label": "appendLiteral", + "kind": "method", + "documentation": "appendLiteral(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLiteral" + }, + { + "label": "appendLocalized", + "kind": "method", + "documentation": "appendLocalized(java.time.format.FormatStyle a, java.time.format.FormatStyle b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalized" + }, + { + "label": "appendLocalizedOffset", + "kind": "method", + "documentation": "appendLocalizedOffset(java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendLocalizedOffset" + }, + { + "label": "appendOffset", + "kind": "method", + "documentation": "appendOffset(java.lang.String a, java.lang.String b): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffset" + }, + { + "label": "appendOffsetId", + "kind": "method", + "documentation": "appendOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOffsetId" + }, + { + "label": "appendOptional", + "kind": "method", + "documentation": "appendOptional(java.time.format.DateTimeFormatter a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendOptional" + }, + { + "label": "appendPattern", + "kind": "method", + "documentation": "appendPattern(java.lang.String a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendPattern" + }, + { + "label": "appendText", + "kind": "method", + "documentation": "appendText(java.time.temporal.TemporalField a, java.time.format.TextStyle b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendText" + }, + { + "label": "appendValue", + "kind": "method", + "documentation": "appendValue(java.time.temporal.TemporalField a, int b, int c, java.time.format.SignStyle d | java.time.temporal.TemporalField a, int b | java.time.temporal.TemporalField a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValue" + }, + { + "label": "appendValueReduced", + "kind": "method", + "documentation": "appendValueReduced(java.time.temporal.TemporalField a, int b, int c, int d): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendValueReduced" + }, + { + "label": "appendZoneId", + "kind": "method", + "documentation": "appendZoneId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneId" + }, + { + "label": "appendZoneOrOffsetId", + "kind": "method", + "documentation": "appendZoneOrOffsetId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneOrOffsetId" + }, + { + "label": "appendZoneRegionId", + "kind": "method", + "documentation": "appendZoneRegionId(): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneRegionId" + }, + { + "label": "appendZoneText", + "kind": "method", + "documentation": "appendZoneText(java.time.format.TextStyle a, java.util.Set b | java.time.format.TextStyle a): java.time.format.DateTimeFormatterBuilder", + "insertText": "appendZoneText" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "optionalEnd", + "kind": "method", + "documentation": "optionalEnd(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalEnd" + }, + { + "label": "optionalStart", + "kind": "method", + "documentation": "optionalStart(): java.time.format.DateTimeFormatterBuilder", + "insertText": "optionalStart" + }, + { + "label": "padNext", + "kind": "method", + "documentation": "padNext(int a, char b | int a): java.time.format.DateTimeFormatterBuilder", + "insertText": "padNext" + }, + { + "label": "parseCaseInsensitive", + "kind": "method", + "documentation": "parseCaseInsensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseInsensitive" + }, + { + "label": "parseCaseSensitive", + "kind": "method", + "documentation": "parseCaseSensitive(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseCaseSensitive" + }, + { + "label": "parseDefaulting", + "kind": "method", + "documentation": "parseDefaulting(java.time.temporal.TemporalField a, long b): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseDefaulting" + }, + { + "label": "parseLenient", + "kind": "method", + "documentation": "parseLenient(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseLenient" + }, + { + "label": "parseStrict", + "kind": "method", + "documentation": "parseStrict(): java.time.format.DateTimeFormatterBuilder", + "insertText": "parseStrict" + }, + { + "label": "toFormatter", + "kind": "method", + "documentation": "toFormatter(java.util.Locale a): java.time.format.DateTimeFormatter", + "insertText": "toFormatter" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeFormatterBuilder", + "kind": "constructor", + "documentation": "Constructor: DateTimeFormatterBuilder", + "insertText": "DateTimeFormatterBuilder" + } + }, + { + "label": "DateTimeParseException", + "kind": "class", + "documentation": "Class: DateTimeParseException", + "insertText": "DateTimeParseException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getParsedString", + "kind": "method", + "documentation": "getParsedString(): java.lang.String", + "insertText": "getParsedString" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DateTimeParseException", + "kind": "constructor", + "documentation": "Constructor: DateTimeParseException", + "insertText": "DateTimeParseException" + } + }, + { + "label": "DecimalStyle", + "kind": "class", + "documentation": "Class: DecimalStyle", + "insertText": "DecimalStyle", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.format.DecimalStyle", + "insertText": "STANDARD" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): java.util.Set", + "insertText": "getAvailableLocales" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.Locale a): java.time.format.DecimalStyle", + "insertText": "of" + }, + { + "label": "ofDefaultLocale", + "kind": "method", + "documentation": "ofDefaultLocale(): java.time.format.DecimalStyle", + "insertText": "ofDefaultLocale" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDecimalSeparator", + "kind": "method", + "documentation": "getDecimalSeparator(): char", + "insertText": "getDecimalSeparator" + }, + { + "label": "getNegativeSign", + "kind": "method", + "documentation": "getNegativeSign(): char", + "insertText": "getNegativeSign" + }, + { + "label": "getPositiveSign", + "kind": "method", + "documentation": "getPositiveSign(): char", + "insertText": "getPositiveSign" + }, + { + "label": "getZeroDigit", + "kind": "method", + "documentation": "getZeroDigit(): char", + "insertText": "getZeroDigit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withDecimalSeparator", + "kind": "method", + "documentation": "withDecimalSeparator(char a): java.time.format.DecimalStyle", + "insertText": "withDecimalSeparator" + }, + { + "label": "withNegativeSign", + "kind": "method", + "documentation": "withNegativeSign(char a): java.time.format.DecimalStyle", + "insertText": "withNegativeSign" + }, + { + "label": "withPositiveSign", + "kind": "method", + "documentation": "withPositiveSign(char a): java.time.format.DecimalStyle", + "insertText": "withPositiveSign" + }, + { + "label": "withZeroDigit", + "kind": "method", + "documentation": "withZeroDigit(char a): java.time.format.DecimalStyle", + "insertText": "withZeroDigit" + } + ] + }, + { + "label": "FormatStyle", + "kind": "class", + "documentation": "Class: FormatStyle", + "insertText": "FormatStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.FormatStyle", + "insertText": "FULL" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: java.time.format.FormatStyle", + "insertText": "LONG" + }, + { + "label": "MEDIUM", + "kind": "property", + "documentation": "MEDIUM: java.time.format.FormatStyle", + "insertText": "MEDIUM" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.FormatStyle", + "insertText": "SHORT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.FormatStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.FormatStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ResolverStyle", + "kind": "class", + "documentation": "Class: ResolverStyle", + "insertText": "ResolverStyle", + "properties": [ + { + "label": "LENIENT", + "kind": "property", + "documentation": "LENIENT: java.time.format.ResolverStyle", + "insertText": "LENIENT" + }, + { + "label": "SMART", + "kind": "property", + "documentation": "SMART: java.time.format.ResolverStyle", + "insertText": "SMART" + }, + { + "label": "STRICT", + "kind": "property", + "documentation": "STRICT: java.time.format.ResolverStyle", + "insertText": "STRICT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.ResolverStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.ResolverStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SignStyle", + "kind": "class", + "documentation": "Class: SignStyle", + "insertText": "SignStyle", + "properties": [ + { + "label": "ALWAYS", + "kind": "property", + "documentation": "ALWAYS: java.time.format.SignStyle", + "insertText": "ALWAYS" + }, + { + "label": "EXCEEDS_PAD", + "kind": "property", + "documentation": "EXCEEDS_PAD: java.time.format.SignStyle", + "insertText": "EXCEEDS_PAD" + }, + { + "label": "NEVER", + "kind": "property", + "documentation": "NEVER: java.time.format.SignStyle", + "insertText": "NEVER" + }, + { + "label": "NORMAL", + "kind": "property", + "documentation": "NORMAL: java.time.format.SignStyle", + "insertText": "NORMAL" + }, + { + "label": "NOT_NEGATIVE", + "kind": "property", + "documentation": "NOT_NEGATIVE: java.time.format.SignStyle", + "insertText": "NOT_NEGATIVE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.SignStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.SignStyle;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TextStyle", + "kind": "class", + "documentation": "Class: TextStyle", + "insertText": "TextStyle", + "properties": [ + { + "label": "FULL", + "kind": "property", + "documentation": "FULL: java.time.format.TextStyle", + "insertText": "FULL" + }, + { + "label": "FULL_STANDALONE", + "kind": "property", + "documentation": "FULL_STANDALONE: java.time.format.TextStyle", + "insertText": "FULL_STANDALONE" + }, + { + "label": "NARROW", + "kind": "property", + "documentation": "NARROW: java.time.format.TextStyle", + "insertText": "NARROW" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: java.time.format.TextStyle", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: java.time.format.TextStyle", + "insertText": "SHORT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: java.time.format.TextStyle", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.format.TextStyle", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.format.TextStyle;", + "insertText": "values" + }, + { + "label": "asNormal", + "kind": "method", + "documentation": "asNormal(): java.time.format.TextStyle", + "insertText": "asNormal" + }, + { + "label": "asStandalone", + "kind": "method", + "documentation": "asStandalone(): java.time.format.TextStyle", + "insertText": "asStandalone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isStandalone", + "kind": "method", + "documentation": "isStandalone(): boolean", + "insertText": "isStandalone" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoField", + "kind": "class", + "documentation": "Class: ChronoField", + "insertText": "ChronoField", + "properties": [ + { + "label": "ALIGNED_DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "ALIGNED_DAY_OF_WEEK_IN_YEAR", + "kind": "property", + "documentation": "ALIGNED_DAY_OF_WEEK_IN_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_DAY_OF_WEEK_IN_YEAR" + }, + { + "label": "ALIGNED_WEEK_OF_MONTH", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_MONTH" + }, + { + "label": "ALIGNED_WEEK_OF_YEAR", + "kind": "property", + "documentation": "ALIGNED_WEEK_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "ALIGNED_WEEK_OF_YEAR" + }, + { + "label": "AMPM_OF_DAY", + "kind": "property", + "documentation": "AMPM_OF_DAY: java.time.temporal.ChronoField", + "insertText": "AMPM_OF_DAY" + }, + { + "label": "CLOCK_HOUR_OF_AMPM", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_AMPM" + }, + { + "label": "CLOCK_HOUR_OF_DAY", + "kind": "property", + "documentation": "CLOCK_HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "CLOCK_HOUR_OF_DAY" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: java.time.temporal.ChronoField", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: java.time.temporal.ChronoField", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "EPOCH_DAY", + "kind": "property", + "documentation": "EPOCH_DAY: java.time.temporal.ChronoField", + "insertText": "EPOCH_DAY" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: java.time.temporal.ChronoField", + "insertText": "ERA" + }, + { + "label": "HOUR_OF_AMPM", + "kind": "property", + "documentation": "HOUR_OF_AMPM: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_AMPM" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: java.time.temporal.ChronoField", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "INSTANT_SECONDS", + "kind": "property", + "documentation": "INSTANT_SECONDS: java.time.temporal.ChronoField", + "insertText": "INSTANT_SECONDS" + }, + { + "label": "MICRO_OF_DAY", + "kind": "property", + "documentation": "MICRO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_DAY" + }, + { + "label": "MICRO_OF_SECOND", + "kind": "property", + "documentation": "MICRO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MICRO_OF_SECOND" + }, + { + "label": "MILLI_OF_DAY", + "kind": "property", + "documentation": "MILLI_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_DAY" + }, + { + "label": "MILLI_OF_SECOND", + "kind": "property", + "documentation": "MILLI_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "MILLI_OF_SECOND" + }, + { + "label": "MINUTE_OF_DAY", + "kind": "property", + "documentation": "MINUTE_OF_DAY: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_DAY" + }, + { + "label": "MINUTE_OF_HOUR", + "kind": "property", + "documentation": "MINUTE_OF_HOUR: java.time.temporal.ChronoField", + "insertText": "MINUTE_OF_HOUR" + }, + { + "label": "MONTH_OF_YEAR", + "kind": "property", + "documentation": "MONTH_OF_YEAR: java.time.temporal.ChronoField", + "insertText": "MONTH_OF_YEAR" + }, + { + "label": "NANO_OF_DAY", + "kind": "property", + "documentation": "NANO_OF_DAY: java.time.temporal.ChronoField", + "insertText": "NANO_OF_DAY" + }, + { + "label": "NANO_OF_SECOND", + "kind": "property", + "documentation": "NANO_OF_SECOND: java.time.temporal.ChronoField", + "insertText": "NANO_OF_SECOND" + }, + { + "label": "OFFSET_SECONDS", + "kind": "property", + "documentation": "OFFSET_SECONDS: java.time.temporal.ChronoField", + "insertText": "OFFSET_SECONDS" + }, + { + "label": "PROLEPTIC_MONTH", + "kind": "property", + "documentation": "PROLEPTIC_MONTH: java.time.temporal.ChronoField", + "insertText": "PROLEPTIC_MONTH" + }, + { + "label": "SECOND_OF_DAY", + "kind": "property", + "documentation": "SECOND_OF_DAY: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_DAY" + }, + { + "label": "SECOND_OF_MINUTE", + "kind": "property", + "documentation": "SECOND_OF_MINUTE: java.time.temporal.ChronoField", + "insertText": "SECOND_OF_MINUTE" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: java.time.temporal.ChronoField", + "insertText": "YEAR" + }, + { + "label": "YEAR_OF_ERA", + "kind": "property", + "documentation": "YEAR_OF_ERA: java.time.temporal.ChronoField", + "insertText": "YEAR_OF_ERA" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoField", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoField;", + "insertText": "values" + }, + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a): long", + "insertText": "checkValidValue" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ChronoUnit", + "kind": "class", + "documentation": "Class: ChronoUnit", + "insertText": "ChronoUnit", + "properties": [ + { + "label": "CENTURIES", + "kind": "property", + "documentation": "CENTURIES: java.time.temporal.ChronoUnit", + "insertText": "CENTURIES" + }, + { + "label": "DAYS", + "kind": "property", + "documentation": "DAYS: java.time.temporal.ChronoUnit", + "insertText": "DAYS" + }, + { + "label": "DECADES", + "kind": "property", + "documentation": "DECADES: java.time.temporal.ChronoUnit", + "insertText": "DECADES" + }, + { + "label": "ERAS", + "kind": "property", + "documentation": "ERAS: java.time.temporal.ChronoUnit", + "insertText": "ERAS" + }, + { + "label": "FOREVER", + "kind": "property", + "documentation": "FOREVER: java.time.temporal.ChronoUnit", + "insertText": "FOREVER" + }, + { + "label": "HALF_DAYS", + "kind": "property", + "documentation": "HALF_DAYS: java.time.temporal.ChronoUnit", + "insertText": "HALF_DAYS" + }, + { + "label": "HOURS", + "kind": "property", + "documentation": "HOURS: java.time.temporal.ChronoUnit", + "insertText": "HOURS" + }, + { + "label": "MICROS", + "kind": "property", + "documentation": "MICROS: java.time.temporal.ChronoUnit", + "insertText": "MICROS" + }, + { + "label": "MILLENNIA", + "kind": "property", + "documentation": "MILLENNIA: java.time.temporal.ChronoUnit", + "insertText": "MILLENNIA" + }, + { + "label": "MILLIS", + "kind": "property", + "documentation": "MILLIS: java.time.temporal.ChronoUnit", + "insertText": "MILLIS" + }, + { + "label": "MINUTES", + "kind": "property", + "documentation": "MINUTES: java.time.temporal.ChronoUnit", + "insertText": "MINUTES" + }, + { + "label": "MONTHS", + "kind": "property", + "documentation": "MONTHS: java.time.temporal.ChronoUnit", + "insertText": "MONTHS" + }, + { + "label": "NANOS", + "kind": "property", + "documentation": "NANOS: java.time.temporal.ChronoUnit", + "insertText": "NANOS" + }, + { + "label": "SECONDS", + "kind": "property", + "documentation": "SECONDS: java.time.temporal.ChronoUnit", + "insertText": "SECONDS" + }, + { + "label": "WEEKS", + "kind": "property", + "documentation": "WEEKS: java.time.temporal.ChronoUnit", + "insertText": "WEEKS" + }, + { + "label": "YEARS", + "kind": "property", + "documentation": "YEARS: java.time.temporal.ChronoUnit", + "insertText": "YEARS" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.temporal.ChronoUnit", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.temporal.ChronoUnit;", + "insertText": "values" + }, + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IsoFields", + "kind": "class", + "documentation": "Class: IsoFields", + "insertText": "IsoFields", + "properties": [ + { + "label": "DAY_OF_QUARTER", + "kind": "property", + "documentation": "DAY_OF_QUARTER: java.time.temporal.TemporalField", + "insertText": "DAY_OF_QUARTER" + }, + { + "label": "QUARTER_OF_YEAR", + "kind": "property", + "documentation": "QUARTER_OF_YEAR: java.time.temporal.TemporalField", + "insertText": "QUARTER_OF_YEAR" + }, + { + "label": "QUARTER_YEARS", + "kind": "property", + "documentation": "QUARTER_YEARS: java.time.temporal.TemporalUnit", + "insertText": "QUARTER_YEARS" + }, + { + "label": "WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_BASED_YEAR" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "WEEK_OF_WEEK_BASED_YEAR", + "kind": "property", + "documentation": "WEEK_OF_WEEK_BASED_YEAR: java.time.temporal.TemporalField", + "insertText": "WEEK_OF_WEEK_BASED_YEAR" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JulianFields", + "kind": "class", + "documentation": "Class: JulianFields", + "insertText": "JulianFields", + "properties": [ + { + "label": "JULIAN_DAY", + "kind": "property", + "documentation": "JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "JULIAN_DAY" + }, + { + "label": "MODIFIED_JULIAN_DAY", + "kind": "property", + "documentation": "MODIFIED_JULIAN_DAY: java.time.temporal.TemporalField", + "insertText": "MODIFIED_JULIAN_DAY" + }, + { + "label": "RATA_DIE", + "kind": "property", + "documentation": "RATA_DIE: java.time.temporal.TemporalField", + "insertText": "RATA_DIE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Temporal", + "kind": "class", + "documentation": "Class: Temporal", + "insertText": "Temporal", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "minus" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.temporal.Temporal", + "insertText": "plus" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.temporal.Temporal", + "insertText": "with" + } + ] + }, + { + "label": "TemporalAccessor", + "kind": "class", + "documentation": "Class: TemporalAccessor", + "insertText": "TemporalAccessor", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjuster", + "kind": "class", + "documentation": "Class: TemporalAdjuster", + "insertText": "TemporalAdjuster", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAdjusters", + "kind": "class", + "documentation": "Class: TemporalAdjusters", + "insertText": "TemporalAdjusters", + "properties": [ + { + "label": "dayOfWeekInMonth", + "kind": "method", + "documentation": "dayOfWeekInMonth(int a, java.time.DayOfWeek b): java.time.temporal.TemporalAdjuster", + "insertText": "dayOfWeekInMonth" + }, + { + "label": "firstDayOfMonth", + "kind": "method", + "documentation": "firstDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfMonth" + }, + { + "label": "firstDayOfNextMonth", + "kind": "method", + "documentation": "firstDayOfNextMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextMonth" + }, + { + "label": "firstDayOfNextYear", + "kind": "method", + "documentation": "firstDayOfNextYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfNextYear" + }, + { + "label": "firstDayOfYear", + "kind": "method", + "documentation": "firstDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "firstDayOfYear" + }, + { + "label": "firstInMonth", + "kind": "method", + "documentation": "firstInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "firstInMonth" + }, + { + "label": "lastDayOfMonth", + "kind": "method", + "documentation": "lastDayOfMonth(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfMonth" + }, + { + "label": "lastDayOfYear", + "kind": "method", + "documentation": "lastDayOfYear(): java.time.temporal.TemporalAdjuster", + "insertText": "lastDayOfYear" + }, + { + "label": "lastInMonth", + "kind": "method", + "documentation": "lastInMonth(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "lastInMonth" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "next" + }, + { + "label": "nextOrSame", + "kind": "method", + "documentation": "nextOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "nextOrSame" + }, + { + "label": "ofDateAdjuster", + "kind": "method", + "documentation": "ofDateAdjuster(java.util.function.UnaryOperator a): java.time.temporal.TemporalAdjuster", + "insertText": "ofDateAdjuster" + }, + { + "label": "previous", + "kind": "method", + "documentation": "previous(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previous" + }, + { + "label": "previousOrSame", + "kind": "method", + "documentation": "previousOrSame(java.time.DayOfWeek a): java.time.temporal.TemporalAdjuster", + "insertText": "previousOrSame" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalAmount", + "kind": "class", + "documentation": "Class: TemporalAmount", + "insertText": "TemporalAmount", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalUnit a): long", + "insertText": "get" + }, + { + "label": "getUnits", + "kind": "method", + "documentation": "getUnits(): java.util.List", + "insertText": "getUnits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "subtractFrom", + "kind": "method", + "documentation": "subtractFrom(java.time.temporal.Temporal a): java.time.temporal.Temporal", + "insertText": "subtractFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalField", + "kind": "class", + "documentation": "Class: TemporalField", + "insertText": "TemporalField", + "properties": [ + { + "label": "adjustInto", + "kind": "method", + "documentation": "adjustInto(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "adjustInto" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBaseUnit", + "kind": "method", + "documentation": "getBaseUnit(): java.time.temporal.TemporalUnit", + "insertText": "getBaseUnit" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getFrom", + "kind": "method", + "documentation": "getFrom(java.time.temporal.TemporalAccessor a): long", + "insertText": "getFrom" + }, + { + "label": "getRangeUnit", + "kind": "method", + "documentation": "getRangeUnit(): java.time.temporal.TemporalUnit", + "insertText": "getRangeUnit" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.TemporalAccessor a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "rangeRefinedBy", + "kind": "method", + "documentation": "rangeRefinedBy(java.time.temporal.TemporalAccessor a): java.time.temporal.ValueRange", + "insertText": "rangeRefinedBy" + }, + { + "label": "resolve", + "kind": "method", + "documentation": "resolve(java.util.Map a, java.time.temporal.TemporalAccessor b, java.time.format.ResolverStyle c): java.time.temporal.TemporalAccessor", + "insertText": "resolve" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQueries", + "kind": "class", + "documentation": "Class: TemporalQueries", + "insertText": "TemporalQueries", + "properties": [ + { + "label": "chronology", + "kind": "method", + "documentation": "chronology(): java.time.temporal.TemporalQuery", + "insertText": "chronology" + }, + { + "label": "localDate", + "kind": "method", + "documentation": "localDate(): java.time.temporal.TemporalQuery", + "insertText": "localDate" + }, + { + "label": "localTime", + "kind": "method", + "documentation": "localTime(): java.time.temporal.TemporalQuery", + "insertText": "localTime" + }, + { + "label": "offset", + "kind": "method", + "documentation": "offset(): java.time.temporal.TemporalQuery", + "insertText": "offset" + }, + { + "label": "precision", + "kind": "method", + "documentation": "precision(): java.time.temporal.TemporalQuery", + "insertText": "precision" + }, + { + "label": "zone", + "kind": "method", + "documentation": "zone(): java.time.temporal.TemporalQuery", + "insertText": "zone" + }, + { + "label": "zoneId", + "kind": "method", + "documentation": "zoneId(): java.time.temporal.TemporalQuery", + "insertText": "zoneId" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalQuery", + "kind": "class", + "documentation": "Class: TemporalQuery", + "insertText": "TemporalQuery", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "queryFrom", + "kind": "method", + "documentation": "queryFrom(java.time.temporal.TemporalAccessor a): org.elasticsearch.painless.lookup.def", + "insertText": "queryFrom" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "TemporalUnit", + "kind": "class", + "documentation": "Class: TemporalUnit", + "insertText": "TemporalUnit", + "properties": [ + { + "label": "addTo", + "kind": "method", + "documentation": "addTo(java.time.temporal.Temporal a, long b): java.time.temporal.Temporal", + "insertText": "addTo" + }, + { + "label": "between", + "kind": "method", + "documentation": "between(java.time.temporal.Temporal a, java.time.temporal.Temporal b): long", + "insertText": "between" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDateBased", + "kind": "method", + "documentation": "isDateBased(): boolean", + "insertText": "isDateBased" + }, + { + "label": "isDurationEstimated", + "kind": "method", + "documentation": "isDurationEstimated(): boolean", + "insertText": "isDurationEstimated" + }, + { + "label": "isSupportedBy", + "kind": "method", + "documentation": "isSupportedBy(java.time.temporal.Temporal a): boolean", + "insertText": "isSupportedBy" + }, + { + "label": "isTimeBased", + "kind": "method", + "documentation": "isTimeBased(): boolean", + "insertText": "isTimeBased" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnsupportedTemporalTypeException", + "kind": "class", + "documentation": "Class: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnsupportedTemporalTypeException", + "kind": "constructor", + "documentation": "Constructor: UnsupportedTemporalTypeException", + "insertText": "UnsupportedTemporalTypeException" + } + }, + { + "label": "ValueRange", + "kind": "class", + "documentation": "Class: ValueRange", + "insertText": "ValueRange", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(long a, long b, long c, long d | long a, long b, long c | long a, long b): java.time.temporal.ValueRange", + "insertText": "of" + }, + { + "label": "checkValidIntValue", + "kind": "method", + "documentation": "checkValidIntValue(long a, java.time.temporal.TemporalField b): int", + "insertText": "checkValidIntValue" + }, + { + "label": "checkValidValue", + "kind": "method", + "documentation": "checkValidValue(long a, java.time.temporal.TemporalField b): long", + "insertText": "checkValidValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLargestMinimum", + "kind": "method", + "documentation": "getLargestMinimum(): long", + "insertText": "getLargestMinimum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(): long", + "insertText": "getMaximum" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(): long", + "insertText": "getMinimum" + }, + { + "label": "getSmallestMaximum", + "kind": "method", + "documentation": "getSmallestMaximum(): long", + "insertText": "getSmallestMaximum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isFixed", + "kind": "method", + "documentation": "isFixed(): boolean", + "insertText": "isFixed" + }, + { + "label": "isIntValue", + "kind": "method", + "documentation": "isIntValue(): boolean", + "insertText": "isIntValue" + }, + { + "label": "isValidIntValue", + "kind": "method", + "documentation": "isValidIntValue(long a): boolean", + "insertText": "isValidIntValue" + }, + { + "label": "isValidValue", + "kind": "method", + "documentation": "isValidValue(long a): boolean", + "insertText": "isValidValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "WeekFields", + "kind": "class", + "documentation": "Class: WeekFields", + "insertText": "WeekFields", + "properties": [ + { + "label": "ISO", + "kind": "property", + "documentation": "ISO: java.time.temporal.WeekFields", + "insertText": "ISO" + }, + { + "label": "SUNDAY_START", + "kind": "property", + "documentation": "SUNDAY_START: java.time.temporal.WeekFields", + "insertText": "SUNDAY_START" + }, + { + "label": "WEEK_BASED_YEARS", + "kind": "property", + "documentation": "WEEK_BASED_YEARS: java.time.temporal.TemporalUnit", + "insertText": "WEEK_BASED_YEARS" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.DayOfWeek a, int b | java.util.Locale a): java.time.temporal.WeekFields", + "insertText": "of" + }, + { + "label": "dayOfWeek", + "kind": "method", + "documentation": "dayOfWeek(): java.time.temporal.TemporalField", + "insertText": "dayOfWeek" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): java.time.DayOfWeek", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "weekBasedYear", + "kind": "method", + "documentation": "weekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekBasedYear" + }, + { + "label": "weekOfMonth", + "kind": "method", + "documentation": "weekOfMonth(): java.time.temporal.TemporalField", + "insertText": "weekOfMonth" + }, + { + "label": "weekOfWeekBasedYear", + "kind": "method", + "documentation": "weekOfWeekBasedYear(): java.time.temporal.TemporalField", + "insertText": "weekOfWeekBasedYear" + }, + { + "label": "weekOfYear", + "kind": "method", + "documentation": "weekOfYear(): java.time.temporal.TemporalField", + "insertText": "weekOfYear" + } + ] + }, + { + "label": "ZoneOffsetTransition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransition", + "insertText": "ZoneOffsetTransition", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.zone.ZoneOffsetTransition", + "insertText": "of" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.zone.ZoneOffsetTransition a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDateTimeAfter", + "kind": "method", + "documentation": "getDateTimeAfter(): java.time.LocalDateTime", + "insertText": "getDateTimeAfter" + }, + { + "label": "getDateTimeBefore", + "kind": "method", + "documentation": "getDateTimeBefore(): java.time.LocalDateTime", + "insertText": "getDateTimeBefore" + }, + { + "label": "getDuration", + "kind": "method", + "documentation": "getDuration(): java.time.Duration", + "insertText": "getDuration" + }, + { + "label": "getInstant", + "kind": "method", + "documentation": "getInstant(): java.time.Instant", + "insertText": "getInstant" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isGap", + "kind": "method", + "documentation": "isGap(): boolean", + "insertText": "isGap" + }, + { + "label": "isOverlap", + "kind": "method", + "documentation": "isOverlap(): boolean", + "insertText": "isOverlap" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.ZoneOffset a): boolean", + "insertText": "isValidOffset" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule", + "insertText": "ZoneOffsetTransitionRule", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.Month a, int b, java.time.DayOfWeek c, java.time.LocalTime d, boolean e, java.time.zone.ZoneOffsetTransitionRule$TimeDefinition f, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined, java.time.ZoneOffset undefined): java.time.zone.ZoneOffsetTransitionRule", + "insertText": "of" + }, + { + "label": "createTransition", + "kind": "method", + "documentation": "createTransition(int a): java.time.zone.ZoneOffsetTransition", + "insertText": "createTransition" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDayOfMonthIndicator", + "kind": "method", + "documentation": "getDayOfMonthIndicator(): int", + "insertText": "getDayOfMonthIndicator" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): java.time.DayOfWeek", + "insertText": "getDayOfWeek" + }, + { + "label": "getLocalTime", + "kind": "method", + "documentation": "getLocalTime(): java.time.LocalTime", + "insertText": "getLocalTime" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getOffsetAfter", + "kind": "method", + "documentation": "getOffsetAfter(): java.time.ZoneOffset", + "insertText": "getOffsetAfter" + }, + { + "label": "getOffsetBefore", + "kind": "method", + "documentation": "getOffsetBefore(): java.time.ZoneOffset", + "insertText": "getOffsetBefore" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTimeDefinition", + "kind": "method", + "documentation": "getTimeDefinition(): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "getTimeDefinition" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isMidnightEndOfDay", + "kind": "method", + "documentation": "isMidnightEndOfDay(): boolean", + "insertText": "isMidnightEndOfDay" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneOffsetTransitionRule.TimeDefinition", + "kind": "class", + "documentation": "Class: ZoneOffsetTransitionRule.TimeDefinition", + "insertText": "ZoneOffsetTransitionRule.TimeDefinition", + "properties": [ + { + "label": "STANDARD", + "kind": "property", + "documentation": "STANDARD: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "STANDARD" + }, + { + "label": "UTC", + "kind": "property", + "documentation": "UTC: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "UTC" + }, + { + "label": "WALL", + "kind": "property", + "documentation": "WALL: java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "WALL" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.time.zone.ZoneOffsetTransitionRule$TimeDefinition", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.time.zone.ZoneOffsetTransitionRule$TimeDefinition;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "createDateTime", + "kind": "method", + "documentation": "createDateTime(java.time.LocalDateTime a, java.time.ZoneOffset b, java.time.ZoneOffset c): java.time.LocalDateTime", + "insertText": "createDateTime" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRules", + "kind": "class", + "documentation": "Class: ZoneRules", + "insertText": "ZoneRules", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.time.ZoneOffset a, java.time.ZoneOffset b, java.util.List c, java.util.List d, java.util.List e | java.time.ZoneOffset a): java.time.zone.ZoneRules", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDaylightSavings", + "kind": "method", + "documentation": "getDaylightSavings(java.time.Instant a): java.time.Duration", + "insertText": "getDaylightSavings" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getStandardOffset", + "kind": "method", + "documentation": "getStandardOffset(java.time.Instant a): java.time.ZoneOffset", + "insertText": "getStandardOffset" + }, + { + "label": "getTransition", + "kind": "method", + "documentation": "getTransition(java.time.LocalDateTime a): java.time.zone.ZoneOffsetTransition", + "insertText": "getTransition" + }, + { + "label": "getTransitionRules", + "kind": "method", + "documentation": "getTransitionRules(): java.util.List", + "insertText": "getTransitionRules" + }, + { + "label": "getTransitions", + "kind": "method", + "documentation": "getTransitions(): java.util.List", + "insertText": "getTransitions" + }, + { + "label": "getValidOffsets", + "kind": "method", + "documentation": "getValidOffsets(java.time.LocalDateTime a): java.util.List", + "insertText": "getValidOffsets" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isDaylightSavings", + "kind": "method", + "documentation": "isDaylightSavings(java.time.Instant a): boolean", + "insertText": "isDaylightSavings" + }, + { + "label": "isFixedOffset", + "kind": "method", + "documentation": "isFixedOffset(): boolean", + "insertText": "isFixedOffset" + }, + { + "label": "isValidOffset", + "kind": "method", + "documentation": "isValidOffset(java.time.LocalDateTime a, java.time.ZoneOffset b): boolean", + "insertText": "isValidOffset" + }, + { + "label": "nextTransition", + "kind": "method", + "documentation": "nextTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "nextTransition" + }, + { + "label": "previousTransition", + "kind": "method", + "documentation": "previousTransition(java.time.Instant a): java.time.zone.ZoneOffsetTransition", + "insertText": "previousTransition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ZoneRulesException", + "kind": "class", + "documentation": "Class: ZoneRulesException", + "insertText": "ZoneRulesException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ZoneRulesException", + "kind": "constructor", + "documentation": "Constructor: ZoneRulesException", + "insertText": "ZoneRulesException" + } + }, + { + "label": "ZoneRulesProvider", + "kind": "class", + "documentation": "Class: ZoneRulesProvider", + "insertText": "ZoneRulesProvider", + "properties": [ + { + "label": "getAvailableZoneIds", + "kind": "method", + "documentation": "getAvailableZoneIds(): java.util.Set", + "insertText": "getAvailableZoneIds" + }, + { + "label": "getRules", + "kind": "method", + "documentation": "getRules(java.lang.String a, boolean b): java.time.zone.ZoneRules", + "insertText": "getRules" + }, + { + "label": "getVersions", + "kind": "method", + "documentation": "getVersions(java.lang.String a): java.util.NavigableMap", + "insertText": "getVersions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractCollection", + "kind": "class", + "documentation": "Class: AbstractCollection", + "insertText": "AbstractCollection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractList", + "kind": "class", + "documentation": "Class: AbstractList", + "insertText": "AbstractList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractMap", + "kind": "class", + "documentation": "Class: AbstractMap", + "insertText": "AbstractMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "AbstractMap.SimpleEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleEntry", + "insertText": "AbstractMap.SimpleEntry" + } + }, + { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "class", + "documentation": "Class: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "AbstractMap.SimpleImmutableEntry", + "kind": "constructor", + "documentation": "Constructor: AbstractMap.SimpleImmutableEntry", + "insertText": "AbstractMap.SimpleImmutableEntry" + } + }, + { + "label": "AbstractQueue", + "kind": "class", + "documentation": "Class: AbstractQueue", + "insertText": "AbstractQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSequentialList", + "kind": "class", + "documentation": "Class: AbstractSequentialList", + "insertText": "AbstractSequentialList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "AbstractSet", + "kind": "class", + "documentation": "Class: AbstractSet", + "insertText": "AbstractSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ArrayDeque", + "kind": "class", + "documentation": "Class: ArrayDeque", + "insertText": "ArrayDeque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): java.util.ArrayDeque", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ArrayDeque", + "kind": "constructor", + "documentation": "Constructor: ArrayDeque", + "insertText": "ArrayDeque" + } + }, + { + "label": "ArrayList", + "kind": "class", + "documentation": "Class: ArrayList", + "insertText": "ArrayList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "trimToSize", + "kind": "method", + "documentation": "trimToSize(): void", + "insertText": "trimToSize" + } + ], + "constructorDefinition": { + "label": "ArrayList", + "kind": "constructor", + "documentation": "Constructor: ArrayList", + "insertText": "ArrayList" + } + }, + { + "label": "Arrays", + "kind": "class", + "documentation": "Class: Arrays", + "insertText": "Arrays", + "properties": [ + { + "label": "asList", + "kind": "method", + "documentation": "asList([Ljava.lang.Object; a): java.util.List", + "insertText": "asList" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals([Ljava.lang.Object; a, [Ljava.lang.Object; b): boolean", + "insertText": "deepEquals" + }, + { + "label": "deepHashCode", + "kind": "method", + "documentation": "deepHashCode([Ljava.lang.Object; a): int", + "insertText": "deepHashCode" + }, + { + "label": "deepToString", + "kind": "method", + "documentation": "deepToString([Ljava.lang.Object; a): java.lang.String", + "insertText": "deepToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64", + "kind": "class", + "documentation": "Class: Base64", + "insertText": "Base64", + "properties": [ + { + "label": "getDecoder", + "kind": "method", + "documentation": "getDecoder(): java.util.Base64$Decoder", + "insertText": "getDecoder" + }, + { + "label": "getEncoder", + "kind": "method", + "documentation": "getEncoder(): java.util.Base64$Encoder", + "insertText": "getEncoder" + }, + { + "label": "getMimeDecoder", + "kind": "method", + "documentation": "getMimeDecoder(): java.util.Base64$Decoder", + "insertText": "getMimeDecoder" + }, + { + "label": "getMimeEncoder", + "kind": "method", + "documentation": "getMimeEncoder(int a, [B b): java.util.Base64$Encoder", + "insertText": "getMimeEncoder" + }, + { + "label": "getUrlDecoder", + "kind": "method", + "documentation": "getUrlDecoder(): java.util.Base64$Decoder", + "insertText": "getUrlDecoder" + }, + { + "label": "getUrlEncoder", + "kind": "method", + "documentation": "getUrlEncoder(): java.util.Base64$Encoder", + "insertText": "getUrlEncoder" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Decoder", + "kind": "class", + "documentation": "Class: Base64.Decoder", + "insertText": "Base64.Decoder", + "properties": [ + { + "label": "decode", + "kind": "method", + "documentation": "decode([B a, [B b | java.lang.String a): int | [B", + "insertText": "decode" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Base64.Encoder", + "kind": "class", + "documentation": "Class: Base64.Encoder", + "insertText": "Base64.Encoder", + "properties": [ + { + "label": "encode", + "kind": "method", + "documentation": "encode([B a, [B b): int", + "insertText": "encode" + }, + { + "label": "encodeToString", + "kind": "method", + "documentation": "encodeToString([B a): java.lang.String", + "insertText": "encodeToString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "withoutPadding", + "kind": "method", + "documentation": "withoutPadding(): java.util.Base64$Encoder", + "insertText": "withoutPadding" + } + ] + }, + { + "label": "BitSet", + "kind": "class", + "documentation": "Class: BitSet", + "insertText": "BitSet", + "properties": [ + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf([J a): java.util.BitSet", + "insertText": "valueOf" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.BitSet a): void", + "insertText": "and" + }, + { + "label": "andNot", + "kind": "method", + "documentation": "andNot(java.util.BitSet a): void", + "insertText": "andNot" + }, + { + "label": "cardinality", + "kind": "method", + "documentation": "cardinality(): int", + "insertText": "cardinality" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a, int b | int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flip", + "kind": "method", + "documentation": "flip(int a, int b | int a): void", + "insertText": "flip" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "intersects", + "kind": "method", + "documentation": "intersects(java.util.BitSet a): boolean", + "insertText": "intersects" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "nextClearBit", + "kind": "method", + "documentation": "nextClearBit(int a): int", + "insertText": "nextClearBit" + }, + { + "label": "nextSetBit", + "kind": "method", + "documentation": "nextSetBit(int a): int", + "insertText": "nextSetBit" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.BitSet a): void", + "insertText": "or" + }, + { + "label": "previousClearBit", + "kind": "method", + "documentation": "previousClearBit(int a): int", + "insertText": "previousClearBit" + }, + { + "label": "previousSetBit", + "kind": "method", + "documentation": "previousSetBit(int a): int", + "insertText": "previousSetBit" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, boolean c | int a, int b | int a): void", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toByteArray", + "kind": "method", + "documentation": "toByteArray(): [B", + "insertText": "toByteArray" + }, + { + "label": "toLongArray", + "kind": "method", + "documentation": "toLongArray(): [J", + "insertText": "toLongArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "xor", + "kind": "method", + "documentation": "xor(java.util.BitSet a): void", + "insertText": "xor" + } + ], + "constructorDefinition": { + "label": "BitSet", + "kind": "constructor", + "documentation": "Constructor: BitSet", + "insertText": "BitSet" + } + }, + { + "label": "Calendar", + "kind": "class", + "documentation": "Class: Calendar", + "insertText": "Calendar", + "properties": [ + { + "label": "ALL_STYLES", + "kind": "property", + "documentation": "ALL_STYLES: int", + "insertText": "ALL_STYLES" + }, + { + "label": "AM", + "kind": "property", + "documentation": "AM: int", + "insertText": "AM" + }, + { + "label": "AM_PM", + "kind": "property", + "documentation": "AM_PM: int", + "insertText": "AM_PM" + }, + { + "label": "APRIL", + "kind": "property", + "documentation": "APRIL: int", + "insertText": "APRIL" + }, + { + "label": "AUGUST", + "kind": "property", + "documentation": "AUGUST: int", + "insertText": "AUGUST" + }, + { + "label": "DATE", + "kind": "property", + "documentation": "DATE: int", + "insertText": "DATE" + }, + { + "label": "DAY_OF_MONTH", + "kind": "property", + "documentation": "DAY_OF_MONTH: int", + "insertText": "DAY_OF_MONTH" + }, + { + "label": "DAY_OF_WEEK", + "kind": "property", + "documentation": "DAY_OF_WEEK: int", + "insertText": "DAY_OF_WEEK" + }, + { + "label": "DAY_OF_WEEK_IN_MONTH", + "kind": "property", + "documentation": "DAY_OF_WEEK_IN_MONTH: int", + "insertText": "DAY_OF_WEEK_IN_MONTH" + }, + { + "label": "DAY_OF_YEAR", + "kind": "property", + "documentation": "DAY_OF_YEAR: int", + "insertText": "DAY_OF_YEAR" + }, + { + "label": "DECEMBER", + "kind": "property", + "documentation": "DECEMBER: int", + "insertText": "DECEMBER" + }, + { + "label": "DST_OFFSET", + "kind": "property", + "documentation": "DST_OFFSET: int", + "insertText": "DST_OFFSET" + }, + { + "label": "ERA", + "kind": "property", + "documentation": "ERA: int", + "insertText": "ERA" + }, + { + "label": "FEBRUARY", + "kind": "property", + "documentation": "FEBRUARY: int", + "insertText": "FEBRUARY" + }, + { + "label": "FIELD_COUNT", + "kind": "property", + "documentation": "FIELD_COUNT: int", + "insertText": "FIELD_COUNT" + }, + { + "label": "FRIDAY", + "kind": "property", + "documentation": "FRIDAY: int", + "insertText": "FRIDAY" + }, + { + "label": "HOUR", + "kind": "property", + "documentation": "HOUR: int", + "insertText": "HOUR" + }, + { + "label": "HOUR_OF_DAY", + "kind": "property", + "documentation": "HOUR_OF_DAY: int", + "insertText": "HOUR_OF_DAY" + }, + { + "label": "JANUARY", + "kind": "property", + "documentation": "JANUARY: int", + "insertText": "JANUARY" + }, + { + "label": "JULY", + "kind": "property", + "documentation": "JULY: int", + "insertText": "JULY" + }, + { + "label": "JUNE", + "kind": "property", + "documentation": "JUNE: int", + "insertText": "JUNE" + }, + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "LONG_FORMAT", + "kind": "property", + "documentation": "LONG_FORMAT: int", + "insertText": "LONG_FORMAT" + }, + { + "label": "LONG_STANDALONE", + "kind": "property", + "documentation": "LONG_STANDALONE: int", + "insertText": "LONG_STANDALONE" + }, + { + "label": "MARCH", + "kind": "property", + "documentation": "MARCH: int", + "insertText": "MARCH" + }, + { + "label": "MAY", + "kind": "property", + "documentation": "MAY: int", + "insertText": "MAY" + }, + { + "label": "MILLISECOND", + "kind": "property", + "documentation": "MILLISECOND: int", + "insertText": "MILLISECOND" + }, + { + "label": "MINUTE", + "kind": "property", + "documentation": "MINUTE: int", + "insertText": "MINUTE" + }, + { + "label": "MONDAY", + "kind": "property", + "documentation": "MONDAY: int", + "insertText": "MONDAY" + }, + { + "label": "MONTH", + "kind": "property", + "documentation": "MONTH: int", + "insertText": "MONTH" + }, + { + "label": "NARROW_FORMAT", + "kind": "property", + "documentation": "NARROW_FORMAT: int", + "insertText": "NARROW_FORMAT" + }, + { + "label": "NARROW_STANDALONE", + "kind": "property", + "documentation": "NARROW_STANDALONE: int", + "insertText": "NARROW_STANDALONE" + }, + { + "label": "NOVEMBER", + "kind": "property", + "documentation": "NOVEMBER: int", + "insertText": "NOVEMBER" + }, + { + "label": "OCTOBER", + "kind": "property", + "documentation": "OCTOBER: int", + "insertText": "OCTOBER" + }, + { + "label": "PM", + "kind": "property", + "documentation": "PM: int", + "insertText": "PM" + }, + { + "label": "SATURDAY", + "kind": "property", + "documentation": "SATURDAY: int", + "insertText": "SATURDAY" + }, + { + "label": "SECOND", + "kind": "property", + "documentation": "SECOND: int", + "insertText": "SECOND" + }, + { + "label": "SEPTEMBER", + "kind": "property", + "documentation": "SEPTEMBER: int", + "insertText": "SEPTEMBER" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "SHORT_FORMAT", + "kind": "property", + "documentation": "SHORT_FORMAT: int", + "insertText": "SHORT_FORMAT" + }, + { + "label": "SHORT_STANDALONE", + "kind": "property", + "documentation": "SHORT_STANDALONE: int", + "insertText": "SHORT_STANDALONE" + }, + { + "label": "SUNDAY", + "kind": "property", + "documentation": "SUNDAY: int", + "insertText": "SUNDAY" + }, + { + "label": "THURSDAY", + "kind": "property", + "documentation": "THURSDAY: int", + "insertText": "THURSDAY" + }, + { + "label": "TUESDAY", + "kind": "property", + "documentation": "TUESDAY: int", + "insertText": "TUESDAY" + }, + { + "label": "UNDECIMBER", + "kind": "property", + "documentation": "UNDECIMBER: int", + "insertText": "UNDECIMBER" + }, + { + "label": "WEDNESDAY", + "kind": "property", + "documentation": "WEDNESDAY: int", + "insertText": "WEDNESDAY" + }, + { + "label": "WEEK_OF_MONTH", + "kind": "property", + "documentation": "WEEK_OF_MONTH: int", + "insertText": "WEEK_OF_MONTH" + }, + { + "label": "WEEK_OF_YEAR", + "kind": "property", + "documentation": "WEEK_OF_YEAR: int", + "insertText": "WEEK_OF_YEAR" + }, + { + "label": "YEAR", + "kind": "property", + "documentation": "YEAR: int", + "insertText": "YEAR" + }, + { + "label": "ZONE_OFFSET", + "kind": "property", + "documentation": "ZONE_OFFSET: int", + "insertText": "ZONE_OFFSET" + }, + { + "label": "getAvailableCalendarTypes", + "kind": "method", + "documentation": "getAvailableCalendarTypes(): java.util.Set", + "insertText": "getAvailableCalendarTypes" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.util.TimeZone a, java.util.Locale b | java.util.TimeZone a): java.util.Calendar", + "insertText": "getInstance" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Calendar.Builder", + "kind": "class", + "documentation": "Class: Calendar.Builder", + "insertText": "Calendar.Builder", + "properties": [ + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Calendar", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b): java.util.Calendar$Builder", + "insertText": "set" + }, + { + "label": "setCalendarType", + "kind": "method", + "documentation": "setCalendarType(java.lang.String a): java.util.Calendar$Builder", + "insertText": "setCalendarType" + }, + { + "label": "setDate", + "kind": "method", + "documentation": "setDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setDate" + }, + { + "label": "setFields", + "kind": "method", + "documentation": "setFields([I a): java.util.Calendar$Builder", + "insertText": "setFields" + }, + { + "label": "setInstant", + "kind": "method", + "documentation": "setInstant(long a): java.util.Calendar$Builder", + "insertText": "setInstant" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): java.util.Calendar$Builder", + "insertText": "setLenient" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Calendar$Builder", + "insertText": "setLocale" + }, + { + "label": "setTimeOfDay", + "kind": "method", + "documentation": "setTimeOfDay(int a, int b, int c, int d | int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setTimeOfDay" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): java.util.Calendar$Builder", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): java.util.Calendar$Builder", + "insertText": "setWeekDate" + }, + { + "label": "setWeekDefinition", + "kind": "method", + "documentation": "setWeekDefinition(int a, int b): java.util.Calendar$Builder", + "insertText": "setWeekDefinition" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Calendar.Builder", + "kind": "constructor", + "documentation": "Constructor: Calendar.Builder", + "insertText": "Calendar.Builder" + } + }, + { + "label": "Collection", + "kind": "class", + "documentation": "Class: Collection", + "insertText": "Collection", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collections", + "kind": "class", + "documentation": "Class: Collections", + "insertText": "Collections", + "properties": [ + { + "label": "EMPTY_LIST", + "kind": "property", + "documentation": "EMPTY_LIST: java.util.List", + "insertText": "EMPTY_LIST" + }, + { + "label": "EMPTY_MAP", + "kind": "property", + "documentation": "EMPTY_MAP: java.util.Map", + "insertText": "EMPTY_MAP" + }, + { + "label": "EMPTY_SET", + "kind": "property", + "documentation": "EMPTY_SET: java.util.Set", + "insertText": "EMPTY_SET" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a, [Lorg.elasticsearch.painless.lookup.def; b): boolean", + "insertText": "addAll" + }, + { + "label": "asLifoQueue", + "kind": "method", + "documentation": "asLifoQueue(java.util.Deque a): java.util.Queue", + "insertText": "asLifoQueue" + }, + { + "label": "binarySearch", + "kind": "method", + "documentation": "binarySearch(java.util.List a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c | java.util.List a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "binarySearch" + }, + { + "label": "copy", + "kind": "method", + "documentation": "copy(java.util.List a, java.util.List b): void", + "insertText": "copy" + }, + { + "label": "disjoint", + "kind": "method", + "documentation": "disjoint(java.util.Collection a, java.util.Collection b): boolean", + "insertText": "disjoint" + }, + { + "label": "emptyEnumeration", + "kind": "method", + "documentation": "emptyEnumeration(): java.util.Enumeration", + "insertText": "emptyEnumeration" + }, + { + "label": "emptyIterator", + "kind": "method", + "documentation": "emptyIterator(): java.util.Iterator", + "insertText": "emptyIterator" + }, + { + "label": "emptyList", + "kind": "method", + "documentation": "emptyList(): java.util.List", + "insertText": "emptyList" + }, + { + "label": "emptyListIterator", + "kind": "method", + "documentation": "emptyListIterator(): java.util.ListIterator", + "insertText": "emptyListIterator" + }, + { + "label": "emptyMap", + "kind": "method", + "documentation": "emptyMap(): java.util.Map", + "insertText": "emptyMap" + }, + { + "label": "emptyNavigableMap", + "kind": "method", + "documentation": "emptyNavigableMap(): java.util.NavigableMap", + "insertText": "emptyNavigableMap" + }, + { + "label": "emptyNavigableSet", + "kind": "method", + "documentation": "emptyNavigableSet(): java.util.NavigableSet", + "insertText": "emptyNavigableSet" + }, + { + "label": "emptySet", + "kind": "method", + "documentation": "emptySet(): java.util.Set", + "insertText": "emptySet" + }, + { + "label": "emptySortedMap", + "kind": "method", + "documentation": "emptySortedMap(): java.util.SortedMap", + "insertText": "emptySortedMap" + }, + { + "label": "emptySortedSet", + "kind": "method", + "documentation": "emptySortedSet(): java.util.SortedSet", + "insertText": "emptySortedSet" + }, + { + "label": "enumeration", + "kind": "method", + "documentation": "enumeration(java.util.Collection a): java.util.Enumeration", + "insertText": "enumeration" + }, + { + "label": "fill", + "kind": "method", + "documentation": "fill(java.util.List a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "fill" + }, + { + "label": "frequency", + "kind": "method", + "documentation": "frequency(java.util.Collection a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "frequency" + }, + { + "label": "indexOfSubList", + "kind": "method", + "documentation": "indexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "indexOfSubList" + }, + { + "label": "lastIndexOfSubList", + "kind": "method", + "documentation": "lastIndexOfSubList(java.util.List a, java.util.List b): int", + "insertText": "lastIndexOfSubList" + }, + { + "label": "list", + "kind": "method", + "documentation": "list(java.util.Enumeration a): java.util.ArrayList", + "insertText": "list" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Collection a, java.util.Comparator b | java.util.Collection a): org.elasticsearch.painless.lookup.def", + "insertText": "min" + }, + { + "label": "nCopies", + "kind": "method", + "documentation": "nCopies(int a, org.elasticsearch.painless.lookup.def b): java.util.List", + "insertText": "nCopies" + }, + { + "label": "newSetFromMap", + "kind": "method", + "documentation": "newSetFromMap(java.util.Map a): java.util.Set", + "insertText": "newSetFromMap" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.List a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c): boolean", + "insertText": "replaceAll" + }, + { + "label": "reverse", + "kind": "method", + "documentation": "reverse(java.util.List a): void", + "insertText": "reverse" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(java.util.Comparator a): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "rotate", + "kind": "method", + "documentation": "rotate(java.util.List a, int b): void", + "insertText": "rotate" + }, + { + "label": "shuffle", + "kind": "method", + "documentation": "shuffle(java.util.List a, java.util.Random b | java.util.List a): void", + "insertText": "shuffle" + }, + { + "label": "singleton", + "kind": "method", + "documentation": "singleton(org.elasticsearch.painless.lookup.def a): java.util.Set", + "insertText": "singleton" + }, + { + "label": "singletonList", + "kind": "method", + "documentation": "singletonList(org.elasticsearch.painless.lookup.def a): java.util.List", + "insertText": "singletonList" + }, + { + "label": "singletonMap", + "kind": "method", + "documentation": "singletonMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.Map", + "insertText": "singletonMap" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.List a, java.util.Comparator b | java.util.List a): void", + "insertText": "sort" + }, + { + "label": "swap", + "kind": "method", + "documentation": "swap(java.util.List a, int b, int c): void", + "insertText": "swap" + }, + { + "label": "unmodifiableCollection", + "kind": "method", + "documentation": "unmodifiableCollection(java.util.Collection a): java.util.Collection", + "insertText": "unmodifiableCollection" + }, + { + "label": "unmodifiableList", + "kind": "method", + "documentation": "unmodifiableList(java.util.List a): java.util.List", + "insertText": "unmodifiableList" + }, + { + "label": "unmodifiableMap", + "kind": "method", + "documentation": "unmodifiableMap(java.util.Map a): java.util.Map", + "insertText": "unmodifiableMap" + }, + { + "label": "unmodifiableNavigableMap", + "kind": "method", + "documentation": "unmodifiableNavigableMap(java.util.NavigableMap a): java.util.NavigableMap", + "insertText": "unmodifiableNavigableMap" + }, + { + "label": "unmodifiableNavigableSet", + "kind": "method", + "documentation": "unmodifiableNavigableSet(java.util.NavigableSet a): java.util.NavigableSet", + "insertText": "unmodifiableNavigableSet" + }, + { + "label": "unmodifiableSet", + "kind": "method", + "documentation": "unmodifiableSet(java.util.Set a): java.util.Set", + "insertText": "unmodifiableSet" + }, + { + "label": "unmodifiableSortedMap", + "kind": "method", + "documentation": "unmodifiableSortedMap(java.util.SortedMap a): java.util.SortedMap", + "insertText": "unmodifiableSortedMap" + }, + { + "label": "unmodifiableSortedSet", + "kind": "method", + "documentation": "unmodifiableSortedSet(java.util.SortedSet a): java.util.SortedSet", + "insertText": "unmodifiableSortedSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Comparator", + "kind": "class", + "documentation": "Class: Comparator", + "insertText": "Comparator", + "properties": [ + { + "label": "comparing", + "kind": "method", + "documentation": "comparing(java.util.function.Function a, java.util.Comparator b | java.util.function.Function a): java.util.Comparator", + "insertText": "comparing" + }, + { + "label": "comparingDouble", + "kind": "method", + "documentation": "comparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "comparingDouble" + }, + { + "label": "comparingInt", + "kind": "method", + "documentation": "comparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "comparingInt" + }, + { + "label": "comparingLong", + "kind": "method", + "documentation": "comparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "comparingLong" + }, + { + "label": "naturalOrder", + "kind": "method", + "documentation": "naturalOrder(): java.util.Comparator", + "insertText": "naturalOrder" + }, + { + "label": "nullsFirst", + "kind": "method", + "documentation": "nullsFirst(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsFirst" + }, + { + "label": "nullsLast", + "kind": "method", + "documentation": "nullsLast(java.util.Comparator a): java.util.Comparator", + "insertText": "nullsLast" + }, + { + "label": "reverseOrder", + "kind": "method", + "documentation": "reverseOrder(): java.util.Comparator", + "insertText": "reverseOrder" + }, + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "compare" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "reversed", + "kind": "method", + "documentation": "reversed(): java.util.Comparator", + "insertText": "reversed" + }, + { + "label": "thenComparing", + "kind": "method", + "documentation": "thenComparing(java.util.function.Function a, java.util.Comparator b | java.util.Comparator a): java.util.Comparator", + "insertText": "thenComparing" + }, + { + "label": "thenComparingDouble", + "kind": "method", + "documentation": "thenComparingDouble(java.util.function.ToDoubleFunction a): java.util.Comparator", + "insertText": "thenComparingDouble" + }, + { + "label": "thenComparingInt", + "kind": "method", + "documentation": "thenComparingInt(java.util.function.ToIntFunction a): java.util.Comparator", + "insertText": "thenComparingInt" + }, + { + "label": "thenComparingLong", + "kind": "method", + "documentation": "thenComparingLong(java.util.function.ToLongFunction a): java.util.Comparator", + "insertText": "thenComparingLong" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ConcurrentModificationException", + "kind": "class", + "documentation": "Class: ConcurrentModificationException", + "insertText": "ConcurrentModificationException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "ConcurrentModificationException", + "kind": "constructor", + "documentation": "Constructor: ConcurrentModificationException", + "insertText": "ConcurrentModificationException" + } + }, + { + "label": "Currency", + "kind": "class", + "documentation": "Class: Currency", + "insertText": "Currency", + "properties": [ + { + "label": "getAvailableCurrencies", + "kind": "method", + "documentation": "getAvailableCurrencies(): java.util.Set", + "insertText": "getAvailableCurrencies" + }, + { + "label": "getInstance", + "kind": "method", + "documentation": "getInstance(java.lang.String a): java.util.Currency", + "insertText": "getInstance" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCurrencyCode", + "kind": "method", + "documentation": "getCurrencyCode(): java.lang.String", + "insertText": "getCurrencyCode" + }, + { + "label": "getDefaultFractionDigits", + "kind": "method", + "documentation": "getDefaultFractionDigits(): int", + "insertText": "getDefaultFractionDigits" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getNumericCode", + "kind": "method", + "documentation": "getNumericCode(): int", + "insertText": "getNumericCode" + }, + { + "label": "getSymbol", + "kind": "method", + "documentation": "getSymbol(java.util.Locale a): java.lang.String", + "insertText": "getSymbol" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Date", + "kind": "class", + "documentation": "Class: Date", + "insertText": "Date", + "properties": [ + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.Instant a): java.util.Date", + "insertText": "from" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.util.Date a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.util.Date a): boolean", + "insertText": "before" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Date a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): long", + "insertText": "getTime" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(long a): void", + "insertText": "setTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Date", + "kind": "constructor", + "documentation": "Constructor: Date", + "insertText": "Date" + } + }, + { + "label": "Deque", + "kind": "class", + "documentation": "Class: Deque", + "insertText": "Deque", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Dictionary", + "kind": "class", + "documentation": "Class: Dictionary", + "insertText": "Dictionary", + "properties": [ + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSummaryStatistics", + "kind": "class", + "documentation": "Class: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.DoubleSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): double", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): double", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): double", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DoubleSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: DoubleSummaryStatistics", + "insertText": "DoubleSummaryStatistics" + } + }, + { + "label": "DuplicateFormatFlagsException", + "kind": "class", + "documentation": "Class: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "DuplicateFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: DuplicateFormatFlagsException", + "insertText": "DuplicateFormatFlagsException" + } + }, + { + "label": "EmptyStackException", + "kind": "class", + "documentation": "Class: EmptyStackException", + "insertText": "EmptyStackException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EmptyStackException", + "kind": "constructor", + "documentation": "Constructor: EmptyStackException", + "insertText": "EmptyStackException" + } + }, + { + "label": "Enumeration", + "kind": "class", + "documentation": "Class: Enumeration", + "insertText": "Enumeration", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListener", + "kind": "class", + "documentation": "Class: EventListener", + "insertText": "EventListener", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventListenerProxy", + "kind": "class", + "documentation": "Class: EventListenerProxy", + "insertText": "EventListenerProxy", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getListener", + "kind": "method", + "documentation": "getListener(): java.util.EventListener", + "insertText": "getListener" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "EventObject", + "kind": "class", + "documentation": "Class: EventObject", + "insertText": "EventObject", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getSource", + "kind": "method", + "documentation": "getSource(): java.lang.Object", + "insertText": "getSource" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "EventObject", + "kind": "constructor", + "documentation": "Constructor: EventObject", + "insertText": "EventObject" + } + }, + { + "label": "FormatFlagsConversionMismatchException", + "kind": "class", + "documentation": "Class: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatFlagsConversionMismatchException", + "kind": "constructor", + "documentation": "Constructor: FormatFlagsConversionMismatchException", + "insertText": "FormatFlagsConversionMismatchException" + } + }, + { + "label": "Formattable", + "kind": "class", + "documentation": "Class: Formattable", + "insertText": "Formattable", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "formatTo", + "kind": "method", + "documentation": "formatTo(java.util.Formatter a, int b, int c, int d): void", + "insertText": "formatTo" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormattableFlags", + "kind": "class", + "documentation": "Class: FormattableFlags", + "insertText": "FormattableFlags", + "properties": [ + { + "label": "ALTERNATE", + "kind": "property", + "documentation": "ALTERNATE: int", + "insertText": "ALTERNATE" + }, + { + "label": "LEFT_JUSTIFY", + "kind": "property", + "documentation": "LEFT_JUSTIFY: int", + "insertText": "LEFT_JUSTIFY" + }, + { + "label": "UPPERCASE", + "kind": "property", + "documentation": "UPPERCASE: int", + "insertText": "UPPERCASE" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Formatter", + "kind": "class", + "documentation": "Class: Formatter", + "insertText": "Formatter", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.util.Locale a, java.lang.String b, [Lorg.elasticsearch.painless.lookup.def; c | java.lang.String a, [Lorg.elasticsearch.painless.lookup.def; b): java.util.Formatter", + "insertText": "format" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "locale", + "kind": "method", + "documentation": "locale(): java.util.Locale", + "insertText": "locale" + }, + { + "label": "out", + "kind": "method", + "documentation": "out(): java.lang.Appendable", + "insertText": "out" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Formatter", + "kind": "constructor", + "documentation": "Constructor: Formatter", + "insertText": "Formatter" + } + }, + { + "label": "Formatter.BigDecimalLayoutForm", + "kind": "class", + "documentation": "Class: Formatter.BigDecimalLayoutForm", + "insertText": "Formatter.BigDecimalLayoutForm", + "properties": [ + { + "label": "DECIMAL_FLOAT", + "kind": "property", + "documentation": "DECIMAL_FLOAT: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "DECIMAL_FLOAT" + }, + { + "label": "SCIENTIFIC", + "kind": "property", + "documentation": "SCIENTIFIC: java.util.Formatter$BigDecimalLayoutForm", + "insertText": "SCIENTIFIC" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FormatterClosedException", + "kind": "class", + "documentation": "Class: FormatterClosedException", + "insertText": "FormatterClosedException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "FormatterClosedException", + "kind": "constructor", + "documentation": "Constructor: FormatterClosedException", + "insertText": "FormatterClosedException" + } + }, + { + "label": "GregorianCalendar", + "kind": "class", + "documentation": "Class: GregorianCalendar", + "insertText": "GregorianCalendar", + "properties": [ + { + "label": "AD", + "kind": "property", + "documentation": "AD: int", + "insertText": "AD" + }, + { + "label": "BC", + "kind": "property", + "documentation": "BC: int", + "insertText": "BC" + }, + { + "label": "from", + "kind": "method", + "documentation": "from(java.time.ZonedDateTime a): java.util.GregorianCalendar", + "insertText": "from" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a, int b): void", + "insertText": "add" + }, + { + "label": "after", + "kind": "method", + "documentation": "after(java.lang.Object a): boolean", + "insertText": "after" + }, + { + "label": "before", + "kind": "method", + "documentation": "before(java.lang.Object a): boolean", + "insertText": "before" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(int a): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.Calendar a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): int", + "insertText": "get" + }, + { + "label": "getActualMaximum", + "kind": "method", + "documentation": "getActualMaximum(int a): int", + "insertText": "getActualMaximum" + }, + { + "label": "getActualMinimum", + "kind": "method", + "documentation": "getActualMinimum(int a): int", + "insertText": "getActualMinimum" + }, + { + "label": "getCalendarType", + "kind": "method", + "documentation": "getCalendarType(): java.lang.String", + "insertText": "getCalendarType" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(int a, int b, java.util.Locale c): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayNames", + "kind": "method", + "documentation": "getDisplayNames(int a, int b, java.util.Locale c): java.util.Map", + "insertText": "getDisplayNames" + }, + { + "label": "getFirstDayOfWeek", + "kind": "method", + "documentation": "getFirstDayOfWeek(): int", + "insertText": "getFirstDayOfWeek" + }, + { + "label": "getGreatestMinimum", + "kind": "method", + "documentation": "getGreatestMinimum(int a): int", + "insertText": "getGreatestMinimum" + }, + { + "label": "getGregorianChange", + "kind": "method", + "documentation": "getGregorianChange(): java.util.Date", + "insertText": "getGregorianChange" + }, + { + "label": "getLeastMaximum", + "kind": "method", + "documentation": "getLeastMaximum(int a): int", + "insertText": "getLeastMaximum" + }, + { + "label": "getMaximum", + "kind": "method", + "documentation": "getMaximum(int a): int", + "insertText": "getMaximum" + }, + { + "label": "getMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "getMinimalDaysInFirstWeek(): int", + "insertText": "getMinimalDaysInFirstWeek" + }, + { + "label": "getMinimum", + "kind": "method", + "documentation": "getMinimum(int a): int", + "insertText": "getMinimum" + }, + { + "label": "getTime", + "kind": "method", + "documentation": "getTime(): java.util.Date", + "insertText": "getTime" + }, + { + "label": "getTimeInMillis", + "kind": "method", + "documentation": "getTimeInMillis(): long", + "insertText": "getTimeInMillis" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "getWeekYear", + "kind": "method", + "documentation": "getWeekYear(): int", + "insertText": "getWeekYear" + }, + { + "label": "getWeeksInWeekYear", + "kind": "method", + "documentation": "getWeeksInWeekYear(): int", + "insertText": "getWeeksInWeekYear" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isLeapYear", + "kind": "method", + "documentation": "isLeapYear(int a): boolean", + "insertText": "isLeapYear" + }, + { + "label": "isLenient", + "kind": "method", + "documentation": "isLenient(): boolean", + "insertText": "isLenient" + }, + { + "label": "isSet", + "kind": "method", + "documentation": "isSet(int a): boolean", + "insertText": "isSet" + }, + { + "label": "isWeekDateSupported", + "kind": "method", + "documentation": "isWeekDateSupported(): boolean", + "insertText": "isWeekDateSupported" + }, + { + "label": "roll", + "kind": "method", + "documentation": "roll(int a, int b): void", + "insertText": "roll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, int b, int c, int d, int e, int f | int a, int b, int c, int d, int e | int a, int b, int c | int a, int b): void", + "insertText": "set" + }, + { + "label": "setFirstDayOfWeek", + "kind": "method", + "documentation": "setFirstDayOfWeek(int a): void", + "insertText": "setFirstDayOfWeek" + }, + { + "label": "setGregorianChange", + "kind": "method", + "documentation": "setGregorianChange(java.util.Date a): void", + "insertText": "setGregorianChange" + }, + { + "label": "setLenient", + "kind": "method", + "documentation": "setLenient(boolean a): void", + "insertText": "setLenient" + }, + { + "label": "setMinimalDaysInFirstWeek", + "kind": "method", + "documentation": "setMinimalDaysInFirstWeek(int a): void", + "insertText": "setMinimalDaysInFirstWeek" + }, + { + "label": "setTime", + "kind": "method", + "documentation": "setTime(java.util.Date a): void", + "insertText": "setTime" + }, + { + "label": "setTimeInMillis", + "kind": "method", + "documentation": "setTimeInMillis(long a): void", + "insertText": "setTimeInMillis" + }, + { + "label": "setTimeZone", + "kind": "method", + "documentation": "setTimeZone(java.util.TimeZone a): void", + "insertText": "setTimeZone" + }, + { + "label": "setWeekDate", + "kind": "method", + "documentation": "setWeekDate(int a, int b, int c): void", + "insertText": "setWeekDate" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZonedDateTime", + "kind": "method", + "documentation": "toZonedDateTime(): java.time.ZonedDateTime", + "insertText": "toZonedDateTime" + } + ], + "constructorDefinition": { + "label": "GregorianCalendar", + "kind": "constructor", + "documentation": "Constructor: GregorianCalendar", + "insertText": "GregorianCalendar" + } + }, + { + "label": "HashMap", + "kind": "class", + "documentation": "Class: HashMap", + "insertText": "HashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "HashMap", + "kind": "constructor", + "documentation": "Constructor: HashMap", + "insertText": "HashMap" + } + }, + { + "label": "HashSet", + "kind": "class", + "documentation": "Class: HashSet", + "insertText": "HashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "HashSet", + "kind": "constructor", + "documentation": "Constructor: HashSet", + "insertText": "HashSet" + } + }, + { + "label": "Hashtable", + "kind": "class", + "documentation": "Class: Hashtable", + "insertText": "Hashtable", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "keys", + "kind": "method", + "documentation": "keys(): java.util.Enumeration", + "insertText": "keys" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "Hashtable", + "kind": "constructor", + "documentation": "Constructor: Hashtable", + "insertText": "Hashtable" + } + }, + { + "label": "IdentityHashMap", + "kind": "class", + "documentation": "Class: IdentityHashMap", + "insertText": "IdentityHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "IdentityHashMap", + "kind": "constructor", + "documentation": "Constructor: IdentityHashMap", + "insertText": "IdentityHashMap" + } + }, + { + "label": "IllegalFormatCodePointException", + "kind": "class", + "documentation": "Class: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCodePoint", + "kind": "method", + "documentation": "getCodePoint(): int", + "insertText": "getCodePoint" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatCodePointException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatCodePointException", + "insertText": "IllegalFormatCodePointException" + } + }, + { + "label": "IllegalFormatConversionException", + "kind": "class", + "documentation": "Class: IllegalFormatConversionException", + "insertText": "IllegalFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): char", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatException", + "kind": "class", + "documentation": "Class: IllegalFormatException", + "insertText": "IllegalFormatException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IllegalFormatFlagsException", + "kind": "class", + "documentation": "Class: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatFlagsException", + "insertText": "IllegalFormatFlagsException" + } + }, + { + "label": "IllegalFormatPrecisionException", + "kind": "class", + "documentation": "Class: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getPrecision", + "kind": "method", + "documentation": "getPrecision(): int", + "insertText": "getPrecision" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatPrecisionException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatPrecisionException", + "insertText": "IllegalFormatPrecisionException" + } + }, + { + "label": "IllegalFormatWidthException", + "kind": "class", + "documentation": "Class: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "getWidth", + "kind": "method", + "documentation": "getWidth(): int", + "insertText": "getWidth" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllegalFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: IllegalFormatWidthException", + "insertText": "IllegalFormatWidthException" + } + }, + { + "label": "IllformedLocaleException", + "kind": "class", + "documentation": "Class: IllformedLocaleException", + "insertText": "IllformedLocaleException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getErrorIndex", + "kind": "method", + "documentation": "getErrorIndex(): int", + "insertText": "getErrorIndex" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IllformedLocaleException", + "kind": "constructor", + "documentation": "Constructor: IllformedLocaleException", + "insertText": "IllformedLocaleException" + } + }, + { + "label": "InputMismatchException", + "kind": "class", + "documentation": "Class: InputMismatchException", + "insertText": "InputMismatchException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "InputMismatchException", + "kind": "constructor", + "documentation": "Constructor: InputMismatchException", + "insertText": "InputMismatchException" + } + }, + { + "label": "IntSummaryStatistics", + "kind": "class", + "documentation": "Class: IntSummaryStatistics", + "insertText": "IntSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.IntSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): int", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): int", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "IntSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: IntSummaryStatistics", + "insertText": "IntSummaryStatistics" + } + }, + { + "label": "Iterator", + "kind": "class", + "documentation": "Class: Iterator", + "insertText": "Iterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LinkedHashMap", + "kind": "class", + "documentation": "Class: LinkedHashMap", + "insertText": "LinkedHashMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "LinkedHashMap", + "kind": "constructor", + "documentation": "Constructor: LinkedHashMap", + "insertText": "LinkedHashMap" + } + }, + { + "label": "LinkedHashSet", + "kind": "class", + "documentation": "Class: LinkedHashSet", + "insertText": "LinkedHashSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedHashSet", + "kind": "constructor", + "documentation": "Constructor: LinkedHashSet", + "insertText": "LinkedHashSet" + } + }, + { + "label": "LinkedList", + "kind": "class", + "documentation": "Class: LinkedList", + "insertText": "LinkedList", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addFirst", + "kind": "method", + "documentation": "addFirst(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addFirst" + }, + { + "label": "addLast", + "kind": "method", + "documentation": "addLast(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addLast" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getFirst", + "kind": "method", + "documentation": "getFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "getFirst" + }, + { + "label": "getLast", + "kind": "method", + "documentation": "getLast(): org.elasticsearch.painless.lookup.def", + "insertText": "getLast" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "offerFirst", + "kind": "method", + "documentation": "offerFirst(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerFirst" + }, + { + "label": "offerLast", + "kind": "method", + "documentation": "offerLast(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offerLast" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "peekFirst", + "kind": "method", + "documentation": "peekFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "peekFirst" + }, + { + "label": "peekLast", + "kind": "method", + "documentation": "peekLast(): org.elasticsearch.painless.lookup.def", + "insertText": "peekLast" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): void", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeFirst", + "kind": "method", + "documentation": "removeFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "removeFirst" + }, + { + "label": "removeFirstOccurrence", + "kind": "method", + "documentation": "removeFirstOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeFirstOccurrence" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "removeLast", + "kind": "method", + "documentation": "removeLast(): org.elasticsearch.painless.lookup.def", + "insertText": "removeLast" + }, + { + "label": "removeLastOccurrence", + "kind": "method", + "documentation": "removeLastOccurrence(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeLastOccurrence" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LinkedList", + "kind": "constructor", + "documentation": "Constructor: LinkedList", + "insertText": "LinkedList" + } + }, + { + "label": "List", + "kind": "class", + "documentation": "Class: List", + "insertText": "List", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ListIterator", + "kind": "class", + "documentation": "Class: ListIterator", + "insertText": "ListIterator", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): void", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hasPrevious", + "kind": "method", + "documentation": "hasPrevious(): boolean", + "insertText": "hasPrevious" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "nextIndex", + "kind": "method", + "documentation": "nextIndex(): int", + "insertText": "nextIndex" + }, + { + "label": "previousIndex", + "kind": "method", + "documentation": "previousIndex(): int", + "insertText": "previousIndex" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(org.elasticsearch.painless.lookup.def a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale", + "kind": "class", + "documentation": "Class: Locale", + "insertText": "Locale", + "properties": [ + { + "label": "CANADA", + "kind": "property", + "documentation": "CANADA: java.util.Locale", + "insertText": "CANADA" + }, + { + "label": "CANADA_FRENCH", + "kind": "property", + "documentation": "CANADA_FRENCH: java.util.Locale", + "insertText": "CANADA_FRENCH" + }, + { + "label": "CHINA", + "kind": "property", + "documentation": "CHINA: java.util.Locale", + "insertText": "CHINA" + }, + { + "label": "CHINESE", + "kind": "property", + "documentation": "CHINESE: java.util.Locale", + "insertText": "CHINESE" + }, + { + "label": "ENGLISH", + "kind": "property", + "documentation": "ENGLISH: java.util.Locale", + "insertText": "ENGLISH" + }, + { + "label": "FRANCE", + "kind": "property", + "documentation": "FRANCE: java.util.Locale", + "insertText": "FRANCE" + }, + { + "label": "FRENCH", + "kind": "property", + "documentation": "FRENCH: java.util.Locale", + "insertText": "FRENCH" + }, + { + "label": "GERMAN", + "kind": "property", + "documentation": "GERMAN: java.util.Locale", + "insertText": "GERMAN" + }, + { + "label": "GERMANY", + "kind": "property", + "documentation": "GERMANY: java.util.Locale", + "insertText": "GERMANY" + }, + { + "label": "ITALIAN", + "kind": "property", + "documentation": "ITALIAN: java.util.Locale", + "insertText": "ITALIAN" + }, + { + "label": "ITALY", + "kind": "property", + "documentation": "ITALY: java.util.Locale", + "insertText": "ITALY" + }, + { + "label": "JAPAN", + "kind": "property", + "documentation": "JAPAN: java.util.Locale", + "insertText": "JAPAN" + }, + { + "label": "JAPANESE", + "kind": "property", + "documentation": "JAPANESE: java.util.Locale", + "insertText": "JAPANESE" + }, + { + "label": "KOREA", + "kind": "property", + "documentation": "KOREA: java.util.Locale", + "insertText": "KOREA" + }, + { + "label": "KOREAN", + "kind": "property", + "documentation": "KOREAN: java.util.Locale", + "insertText": "KOREAN" + }, + { + "label": "PRC", + "kind": "property", + "documentation": "PRC: java.util.Locale", + "insertText": "PRC" + }, + { + "label": "PRIVATE_USE_EXTENSION", + "kind": "property", + "documentation": "PRIVATE_USE_EXTENSION: char", + "insertText": "PRIVATE_USE_EXTENSION" + }, + { + "label": "ROOT", + "kind": "property", + "documentation": "ROOT: java.util.Locale", + "insertText": "ROOT" + }, + { + "label": "SIMPLIFIED_CHINESE", + "kind": "property", + "documentation": "SIMPLIFIED_CHINESE: java.util.Locale", + "insertText": "SIMPLIFIED_CHINESE" + }, + { + "label": "TAIWAN", + "kind": "property", + "documentation": "TAIWAN: java.util.Locale", + "insertText": "TAIWAN" + }, + { + "label": "TRADITIONAL_CHINESE", + "kind": "property", + "documentation": "TRADITIONAL_CHINESE: java.util.Locale", + "insertText": "TRADITIONAL_CHINESE" + }, + { + "label": "UK", + "kind": "property", + "documentation": "UK: java.util.Locale", + "insertText": "UK" + }, + { + "label": "UNICODE_LOCALE_EXTENSION", + "kind": "property", + "documentation": "UNICODE_LOCALE_EXTENSION: char", + "insertText": "UNICODE_LOCALE_EXTENSION" + }, + { + "label": "US", + "kind": "property", + "documentation": "US: java.util.Locale", + "insertText": "US" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filter" + }, + { + "label": "filterTags", + "kind": "method", + "documentation": "filterTags(java.util.List a, java.util.Collection b): java.util.List", + "insertText": "filterTags" + }, + { + "label": "forLanguageTag", + "kind": "method", + "documentation": "forLanguageTag(java.lang.String a): java.util.Locale", + "insertText": "forLanguageTag" + }, + { + "label": "getAvailableLocales", + "kind": "method", + "documentation": "getAvailableLocales(): [Ljava.util.Locale;", + "insertText": "getAvailableLocales" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(java.util.Locale$Category a): java.util.Locale", + "insertText": "getDefault" + }, + { + "label": "getISOCountries", + "kind": "method", + "documentation": "getISOCountries(): [Ljava.lang.String;", + "insertText": "getISOCountries" + }, + { + "label": "getISOLanguages", + "kind": "method", + "documentation": "getISOLanguages(): [Ljava.lang.String;", + "insertText": "getISOLanguages" + }, + { + "label": "lookup", + "kind": "method", + "documentation": "lookup(java.util.List a, java.util.Collection b): java.util.Locale", + "insertText": "lookup" + }, + { + "label": "lookupTag", + "kind": "method", + "documentation": "lookupTag(java.util.List a, java.util.Collection b): java.lang.String", + "insertText": "lookupTag" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getCountry", + "kind": "method", + "documentation": "getCountry(): java.lang.String", + "insertText": "getCountry" + }, + { + "label": "getDisplayCountry", + "kind": "method", + "documentation": "getDisplayCountry(java.util.Locale a): java.lang.String", + "insertText": "getDisplayCountry" + }, + { + "label": "getDisplayLanguage", + "kind": "method", + "documentation": "getDisplayLanguage(java.util.Locale a): java.lang.String", + "insertText": "getDisplayLanguage" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getDisplayScript", + "kind": "method", + "documentation": "getDisplayScript(java.util.Locale a): java.lang.String", + "insertText": "getDisplayScript" + }, + { + "label": "getDisplayVariant", + "kind": "method", + "documentation": "getDisplayVariant(java.util.Locale a): java.lang.String", + "insertText": "getDisplayVariant" + }, + { + "label": "getExtension", + "kind": "method", + "documentation": "getExtension(char a): java.lang.String", + "insertText": "getExtension" + }, + { + "label": "getExtensionKeys", + "kind": "method", + "documentation": "getExtensionKeys(): java.util.Set", + "insertText": "getExtensionKeys" + }, + { + "label": "getISO3Country", + "kind": "method", + "documentation": "getISO3Country(): java.lang.String", + "insertText": "getISO3Country" + }, + { + "label": "getISO3Language", + "kind": "method", + "documentation": "getISO3Language(): java.lang.String", + "insertText": "getISO3Language" + }, + { + "label": "getLanguage", + "kind": "method", + "documentation": "getLanguage(): java.lang.String", + "insertText": "getLanguage" + }, + { + "label": "getScript", + "kind": "method", + "documentation": "getScript(): java.lang.String", + "insertText": "getScript" + }, + { + "label": "getUnicodeLocaleAttributes", + "kind": "method", + "documentation": "getUnicodeLocaleAttributes(): java.util.Set", + "insertText": "getUnicodeLocaleAttributes" + }, + { + "label": "getUnicodeLocaleKeys", + "kind": "method", + "documentation": "getUnicodeLocaleKeys(): java.util.Set", + "insertText": "getUnicodeLocaleKeys" + }, + { + "label": "getUnicodeLocaleType", + "kind": "method", + "documentation": "getUnicodeLocaleType(java.lang.String a): java.lang.String", + "insertText": "getUnicodeLocaleType" + }, + { + "label": "getVariant", + "kind": "method", + "documentation": "getVariant(): java.lang.String", + "insertText": "getVariant" + }, + { + "label": "hasExtensions", + "kind": "method", + "documentation": "hasExtensions(): boolean", + "insertText": "hasExtensions" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "stripExtensions", + "kind": "method", + "documentation": "stripExtensions(): java.util.Locale", + "insertText": "stripExtensions" + }, + { + "label": "toLanguageTag", + "kind": "method", + "documentation": "toLanguageTag(): java.lang.String", + "insertText": "toLanguageTag" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale", + "kind": "constructor", + "documentation": "Constructor: Locale", + "insertText": "Locale" + } + }, + { + "label": "Locale.Builder", + "kind": "class", + "documentation": "Class: Locale.Builder", + "insertText": "Locale.Builder", + "properties": [ + { + "label": "addUnicodeLocaleAttribute", + "kind": "method", + "documentation": "addUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "addUnicodeLocaleAttribute" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.Locale", + "insertText": "build" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): java.util.Locale$Builder", + "insertText": "clear" + }, + { + "label": "clearExtensions", + "kind": "method", + "documentation": "clearExtensions(): java.util.Locale$Builder", + "insertText": "clearExtensions" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "removeUnicodeLocaleAttribute", + "kind": "method", + "documentation": "removeUnicodeLocaleAttribute(java.lang.String a): java.util.Locale$Builder", + "insertText": "removeUnicodeLocaleAttribute" + }, + { + "label": "setExtension", + "kind": "method", + "documentation": "setExtension(char a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setExtension" + }, + { + "label": "setLanguage", + "kind": "method", + "documentation": "setLanguage(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguage" + }, + { + "label": "setLanguageTag", + "kind": "method", + "documentation": "setLanguageTag(java.lang.String a): java.util.Locale$Builder", + "insertText": "setLanguageTag" + }, + { + "label": "setLocale", + "kind": "method", + "documentation": "setLocale(java.util.Locale a): java.util.Locale$Builder", + "insertText": "setLocale" + }, + { + "label": "setRegion", + "kind": "method", + "documentation": "setRegion(java.lang.String a): java.util.Locale$Builder", + "insertText": "setRegion" + }, + { + "label": "setScript", + "kind": "method", + "documentation": "setScript(java.lang.String a): java.util.Locale$Builder", + "insertText": "setScript" + }, + { + "label": "setUnicodeLocaleKeyword", + "kind": "method", + "documentation": "setUnicodeLocaleKeyword(java.lang.String a, java.lang.String b): java.util.Locale$Builder", + "insertText": "setUnicodeLocaleKeyword" + }, + { + "label": "setVariant", + "kind": "method", + "documentation": "setVariant(java.lang.String a): java.util.Locale$Builder", + "insertText": "setVariant" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.Builder", + "kind": "constructor", + "documentation": "Constructor: Locale.Builder", + "insertText": "Locale.Builder" + } + }, + { + "label": "Locale.Category", + "kind": "class", + "documentation": "Class: Locale.Category", + "insertText": "Locale.Category", + "properties": [ + { + "label": "DISPLAY", + "kind": "property", + "documentation": "DISPLAY: java.util.Locale$Category", + "insertText": "DISPLAY" + }, + { + "label": "FORMAT", + "kind": "property", + "documentation": "FORMAT: java.util.Locale$Category", + "insertText": "FORMAT" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$Category", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$Category;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.FilteringMode", + "kind": "class", + "documentation": "Class: Locale.FilteringMode", + "insertText": "Locale.FilteringMode", + "properties": [ + { + "label": "AUTOSELECT_FILTERING", + "kind": "property", + "documentation": "AUTOSELECT_FILTERING: java.util.Locale$FilteringMode", + "insertText": "AUTOSELECT_FILTERING" + }, + { + "label": "EXTENDED_FILTERING", + "kind": "property", + "documentation": "EXTENDED_FILTERING: java.util.Locale$FilteringMode", + "insertText": "EXTENDED_FILTERING" + }, + { + "label": "IGNORE_EXTENDED_RANGES", + "kind": "property", + "documentation": "IGNORE_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "IGNORE_EXTENDED_RANGES" + }, + { + "label": "MAP_EXTENDED_RANGES", + "kind": "property", + "documentation": "MAP_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "MAP_EXTENDED_RANGES" + }, + { + "label": "REJECT_EXTENDED_RANGES", + "kind": "property", + "documentation": "REJECT_EXTENDED_RANGES: java.util.Locale$FilteringMode", + "insertText": "REJECT_EXTENDED_RANGES" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.Locale$FilteringMode", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.Locale$FilteringMode;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Locale.LanguageRange", + "kind": "class", + "documentation": "Class: Locale.LanguageRange", + "insertText": "Locale.LanguageRange", + "properties": [ + { + "label": "MAX_WEIGHT", + "kind": "property", + "documentation": "MAX_WEIGHT: double", + "insertText": "MAX_WEIGHT" + }, + { + "label": "MIN_WEIGHT", + "kind": "property", + "documentation": "MIN_WEIGHT: double", + "insertText": "MIN_WEIGHT" + }, + { + "label": "mapEquivalents", + "kind": "method", + "documentation": "mapEquivalents(java.util.List a, java.util.Map b): java.util.List", + "insertText": "mapEquivalents" + }, + { + "label": "parse", + "kind": "method", + "documentation": "parse(java.lang.String a, java.util.Map b | java.lang.String a): java.util.List", + "insertText": "parse" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getRange", + "kind": "method", + "documentation": "getRange(): java.lang.String", + "insertText": "getRange" + }, + { + "label": "getWeight", + "kind": "method", + "documentation": "getWeight(): double", + "insertText": "getWeight" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Locale.LanguageRange", + "kind": "constructor", + "documentation": "Constructor: Locale.LanguageRange", + "insertText": "Locale.LanguageRange" + } + }, + { + "label": "LongSummaryStatistics", + "kind": "class", + "documentation": "Class: LongSummaryStatistics", + "insertText": "LongSummaryStatistics", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "combine", + "kind": "method", + "documentation": "combine(java.util.LongSummaryStatistics a): void", + "insertText": "combine" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAverage", + "kind": "method", + "documentation": "getAverage(): double", + "insertText": "getAverage" + }, + { + "label": "getCount", + "kind": "method", + "documentation": "getCount(): long", + "insertText": "getCount" + }, + { + "label": "getMax", + "kind": "method", + "documentation": "getMax(): long", + "insertText": "getMax" + }, + { + "label": "getMin", + "kind": "method", + "documentation": "getMin(): long", + "insertText": "getMin" + }, + { + "label": "getSum", + "kind": "method", + "documentation": "getSum(): long", + "insertText": "getSum" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "LongSummaryStatistics", + "kind": "constructor", + "documentation": "Constructor: LongSummaryStatistics", + "insertText": "LongSummaryStatistics" + } + }, + { + "label": "Map", + "kind": "class", + "documentation": "Class: Map", + "insertText": "Map", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "Map.Entry", + "kind": "class", + "documentation": "Class: Map.Entry", + "insertText": "Map.Entry", + "properties": [ + { + "label": "comparingByKey", + "kind": "method", + "documentation": "comparingByKey(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByKey" + }, + { + "label": "comparingByValue", + "kind": "method", + "documentation": "comparingByValue(java.util.Comparator a): java.util.Comparator", + "insertText": "comparingByValue" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): org.elasticsearch.painless.lookup.def", + "insertText": "getKey" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "setValue", + "kind": "method", + "documentation": "setValue(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "setValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "MissingFormatArgumentException", + "kind": "class", + "documentation": "Class: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatArgumentException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatArgumentException", + "insertText": "MissingFormatArgumentException" + } + }, + { + "label": "MissingFormatWidthException", + "kind": "class", + "documentation": "Class: MissingFormatWidthException", + "insertText": "MissingFormatWidthException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFormatSpecifier", + "kind": "method", + "documentation": "getFormatSpecifier(): java.lang.String", + "insertText": "getFormatSpecifier" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingFormatWidthException", + "kind": "constructor", + "documentation": "Constructor: MissingFormatWidthException", + "insertText": "MissingFormatWidthException" + } + }, + { + "label": "MissingResourceException", + "kind": "class", + "documentation": "Class: MissingResourceException", + "insertText": "MissingResourceException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getClassName", + "kind": "method", + "documentation": "getClassName(): java.lang.String", + "insertText": "getClassName" + }, + { + "label": "getKey", + "kind": "method", + "documentation": "getKey(): java.lang.String", + "insertText": "getKey" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "MissingResourceException", + "kind": "constructor", + "documentation": "Constructor: MissingResourceException", + "insertText": "MissingResourceException" + } + }, + { + "label": "NavigableMap", + "kind": "class", + "documentation": "Class: NavigableMap", + "insertText": "NavigableMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "NavigableSet", + "kind": "class", + "documentation": "Class: NavigableSet", + "insertText": "NavigableSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "NoSuchElementException", + "kind": "class", + "documentation": "Class: NoSuchElementException", + "insertText": "NoSuchElementException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "NoSuchElementException", + "kind": "constructor", + "documentation": "Constructor: NoSuchElementException", + "insertText": "NoSuchElementException" + } + }, + { + "label": "Objects", + "kind": "class", + "documentation": "Class: Objects", + "insertText": "Objects", + "properties": [ + { + "label": "compare", + "kind": "method", + "documentation": "compare(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.Comparator c): int", + "insertText": "compare" + }, + { + "label": "deepEquals", + "kind": "method", + "documentation": "deepEquals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "deepEquals" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a, java.lang.Object b): boolean", + "insertText": "equals" + }, + { + "label": "hash", + "kind": "method", + "documentation": "hash([Ljava.lang.Object; a): int", + "insertText": "hash" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(java.lang.Object a): int", + "insertText": "hashCode" + }, + { + "label": "isNull", + "kind": "method", + "documentation": "isNull(java.lang.Object a): boolean", + "insertText": "isNull" + }, + { + "label": "nonNull", + "kind": "method", + "documentation": "nonNull(java.lang.Object a): boolean", + "insertText": "nonNull" + }, + { + "label": "requireNonNull", + "kind": "method", + "documentation": "requireNonNull(org.elasticsearch.painless.lookup.def a, java.lang.String b | org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "requireNonNull" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.Object a, java.lang.String b | java.lang.Object a): java.lang.String", + "insertText": "toString" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Observable", + "kind": "class", + "documentation": "Class: Observable", + "insertText": "Observable", + "properties": [ + { + "label": "addObserver", + "kind": "method", + "documentation": "addObserver(java.util.Observer a): void", + "insertText": "addObserver" + }, + { + "label": "countObservers", + "kind": "method", + "documentation": "countObservers(): int", + "insertText": "countObservers" + }, + { + "label": "deleteObserver", + "kind": "method", + "documentation": "deleteObserver(java.util.Observer a): void", + "insertText": "deleteObserver" + }, + { + "label": "deleteObservers", + "kind": "method", + "documentation": "deleteObservers(): void", + "insertText": "deleteObservers" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasChanged", + "kind": "method", + "documentation": "hasChanged(): boolean", + "insertText": "hasChanged" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "notifyObservers", + "kind": "method", + "documentation": "notifyObservers(java.lang.Object a): void", + "insertText": "notifyObservers" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Observable", + "kind": "constructor", + "documentation": "Constructor: Observable", + "insertText": "Observable" + } + }, + { + "label": "Observer", + "kind": "class", + "documentation": "Class: Observer", + "insertText": "Observer", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "update", + "kind": "method", + "documentation": "update(java.util.Observable a, java.lang.Object b): void", + "insertText": "update" + } + ] + }, + { + "label": "Optional", + "kind": "class", + "documentation": "Class: Optional", + "insertText": "Optional", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.Optional", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "of" + }, + { + "label": "ofNullable", + "kind": "method", + "documentation": "ofNullable(org.elasticsearch.painless.lookup.def a): java.util.Optional", + "insertText": "ofNullable" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.Optional", + "insertText": "filter" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.Optional", + "insertText": "flatMap" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.Consumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.Optional", + "insertText": "map" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): org.elasticsearch.painless.lookup.def", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalDouble", + "kind": "class", + "documentation": "Class: OptionalDouble", + "insertText": "OptionalDouble", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalDouble", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(double a): java.util.OptionalDouble", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.DoubleConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(double a): double", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.DoubleSupplier a): double", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): double", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalInt", + "kind": "class", + "documentation": "Class: OptionalInt", + "insertText": "OptionalInt", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalInt", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(int a): java.util.OptionalInt", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.IntConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(int a): int", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.IntSupplier a): int", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): int", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "OptionalLong", + "kind": "class", + "documentation": "Class: OptionalLong", + "insertText": "OptionalLong", + "properties": [ + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.OptionalLong", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of(long a): java.util.OptionalLong", + "insertText": "of" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ifPresent", + "kind": "method", + "documentation": "ifPresent(java.util.function.LongConsumer a): void", + "insertText": "ifPresent" + }, + { + "label": "isPresent", + "kind": "method", + "documentation": "isPresent(): boolean", + "insertText": "isPresent" + }, + { + "label": "orElse", + "kind": "method", + "documentation": "orElse(long a): long", + "insertText": "orElse" + }, + { + "label": "orElseGet", + "kind": "method", + "documentation": "orElseGet(java.util.function.LongSupplier a): long", + "insertText": "orElseGet" + }, + { + "label": "orElseThrow", + "kind": "method", + "documentation": "orElseThrow(java.util.function.Supplier a): long", + "insertText": "orElseThrow" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator", + "kind": "class", + "documentation": "Class: PrimitiveIterator", + "insertText": "PrimitiveIterator", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): org.elasticsearch.painless.lookup.def", + "insertText": "next" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfDouble", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfDouble", + "insertText": "PrimitiveIterator.OfDouble", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Double", + "insertText": "next" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfInt", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfInt", + "insertText": "PrimitiveIterator.OfInt", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Integer", + "insertText": "next" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(): int", + "insertText": "nextInt" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PrimitiveIterator.OfLong", + "kind": "class", + "documentation": "Class: PrimitiveIterator.OfLong", + "insertText": "PrimitiveIterator.OfLong", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "hasNext", + "kind": "method", + "documentation": "hasNext(): boolean", + "insertText": "hasNext" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "next", + "kind": "method", + "documentation": "next(): java.lang.Long", + "insertText": "next" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): void", + "insertText": "remove" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "PriorityQueue", + "kind": "class", + "documentation": "Class: PriorityQueue", + "insertText": "PriorityQueue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "PriorityQueue", + "kind": "constructor", + "documentation": "Constructor: PriorityQueue", + "insertText": "PriorityQueue" + } + }, + { + "label": "Queue", + "kind": "class", + "documentation": "Class: Queue", + "insertText": "Queue", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "element", + "kind": "method", + "documentation": "element(): org.elasticsearch.painless.lookup.def", + "insertText": "element" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "offer", + "kind": "method", + "documentation": "offer(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "offer" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "poll", + "kind": "method", + "documentation": "poll(): org.elasticsearch.painless.lookup.def", + "insertText": "poll" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Random", + "kind": "class", + "documentation": "Class: Random", + "insertText": "Random", + "properties": [ + { + "label": "doubles", + "kind": "method", + "documentation": "doubles(long a, double b, double c | long a): java.util.stream.DoubleStream", + "insertText": "doubles" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "ints", + "kind": "method", + "documentation": "ints(long a, int b, int c | long a): java.util.stream.IntStream", + "insertText": "ints" + }, + { + "label": "longs", + "kind": "method", + "documentation": "longs(long a, long b, long c | long a): java.util.stream.LongStream", + "insertText": "longs" + }, + { + "label": "nextBoolean", + "kind": "method", + "documentation": "nextBoolean(): boolean", + "insertText": "nextBoolean" + }, + { + "label": "nextBytes", + "kind": "method", + "documentation": "nextBytes([B a): void", + "insertText": "nextBytes" + }, + { + "label": "nextDouble", + "kind": "method", + "documentation": "nextDouble(): double", + "insertText": "nextDouble" + }, + { + "label": "nextFloat", + "kind": "method", + "documentation": "nextFloat(): float", + "insertText": "nextFloat" + }, + { + "label": "nextGaussian", + "kind": "method", + "documentation": "nextGaussian(): double", + "insertText": "nextGaussian" + }, + { + "label": "nextInt", + "kind": "method", + "documentation": "nextInt(int a): int", + "insertText": "nextInt" + }, + { + "label": "nextLong", + "kind": "method", + "documentation": "nextLong(): long", + "insertText": "nextLong" + }, + { + "label": "setSeed", + "kind": "method", + "documentation": "setSeed(long a): void", + "insertText": "setSeed" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Random", + "kind": "constructor", + "documentation": "Constructor: Random", + "insertText": "Random" + } + }, + { + "label": "RandomAccess", + "kind": "class", + "documentation": "Class: RandomAccess", + "insertText": "RandomAccess", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Set", + "kind": "class", + "documentation": "Class: Set", + "insertText": "Set", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "SimpleTimeZone", + "kind": "class", + "documentation": "Class: SimpleTimeZone", + "insertText": "SimpleTimeZone", + "properties": [ + { + "label": "STANDARD_TIME", + "kind": "property", + "documentation": "STANDARD_TIME: int", + "insertText": "STANDARD_TIME" + }, + { + "label": "UTC_TIME", + "kind": "property", + "documentation": "UTC_TIME: int", + "insertText": "UTC_TIME" + }, + { + "label": "WALL_TIME", + "kind": "property", + "documentation": "WALL_TIME: int", + "insertText": "WALL_TIME" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setDSTSavings", + "kind": "method", + "documentation": "setDSTSavings(int a): void", + "insertText": "setDSTSavings" + }, + { + "label": "setEndRule", + "kind": "method", + "documentation": "setEndRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setEndRule" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "setStartRule", + "kind": "method", + "documentation": "setStartRule(int a, int b, int c, int d, boolean e | int a, int b, int c, int d | int a, int b, int c): void", + "insertText": "setStartRule" + }, + { + "label": "setStartYear", + "kind": "method", + "documentation": "setStartYear(int a): void", + "insertText": "setStartYear" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ], + "constructorDefinition": { + "label": "SimpleTimeZone", + "kind": "constructor", + "documentation": "Constructor: SimpleTimeZone", + "insertText": "SimpleTimeZone" + } + }, + { + "label": "SortedMap", + "kind": "class", + "documentation": "Class: SortedMap", + "insertText": "SortedMap", + "properties": [ + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a): java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ] + }, + { + "label": "SortedSet", + "kind": "class", + "documentation": "Class: SortedSet", + "insertText": "SortedSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a): java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Spliterator", + "kind": "class", + "documentation": "Class: Spliterator", + "insertText": "Spliterator", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: int", + "insertText": "CONCURRENT" + }, + { + "label": "DISTINCT", + "kind": "property", + "documentation": "DISTINCT: int", + "insertText": "DISTINCT" + }, + { + "label": "IMMUTABLE", + "kind": "property", + "documentation": "IMMUTABLE: int", + "insertText": "IMMUTABLE" + }, + { + "label": "NONNULL", + "kind": "property", + "documentation": "NONNULL: int", + "insertText": "NONNULL" + }, + { + "label": "ORDERED", + "kind": "property", + "documentation": "ORDERED: int", + "insertText": "ORDERED" + }, + { + "label": "SIZED", + "kind": "property", + "documentation": "SIZED: int", + "insertText": "SIZED" + }, + { + "label": "SORTED", + "kind": "property", + "documentation": "SORTED: int", + "insertText": "SORTED" + }, + { + "label": "SUBSIZED", + "kind": "property", + "documentation": "SUBSIZED: int", + "insertText": "SUBSIZED" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(java.util.function.Consumer a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(java.util.function.Consumer a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfDouble", + "kind": "class", + "documentation": "Class: Spliterator.OfDouble", + "insertText": "Spliterator.OfDouble", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfDouble", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfInt", + "kind": "class", + "documentation": "Class: Spliterator.OfInt", + "insertText": "Spliterator.OfInt", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfInt", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfLong", + "kind": "class", + "documentation": "Class: Spliterator.OfLong", + "insertText": "Spliterator.OfLong", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfLong", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterator.OfPrimitive", + "kind": "class", + "documentation": "Class: Spliterator.OfPrimitive", + "insertText": "Spliterator.OfPrimitive", + "properties": [ + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): int", + "insertText": "characteristics" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "estimateSize", + "kind": "method", + "documentation": "estimateSize(): long", + "insertText": "estimateSize" + }, + { + "label": "forEachRemaining", + "kind": "method", + "documentation": "forEachRemaining(org.elasticsearch.painless.lookup.def a): void", + "insertText": "forEachRemaining" + }, + { + "label": "getComparator", + "kind": "method", + "documentation": "getComparator(): java.util.Comparator", + "insertText": "getComparator" + }, + { + "label": "getExactSizeIfKnown", + "kind": "method", + "documentation": "getExactSizeIfKnown(): long", + "insertText": "getExactSizeIfKnown" + }, + { + "label": "hasCharacteristics", + "kind": "method", + "documentation": "hasCharacteristics(int a): boolean", + "insertText": "hasCharacteristics" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "tryAdvance", + "kind": "method", + "documentation": "tryAdvance(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "tryAdvance" + }, + { + "label": "trySplit", + "kind": "method", + "documentation": "trySplit(): java.util.Spliterator$OfPrimitive", + "insertText": "trySplit" + } + ] + }, + { + "label": "Spliterators", + "kind": "class", + "documentation": "Class: Spliterators", + "insertText": "Spliterators", + "properties": [ + { + "label": "emptyDoubleSpliterator", + "kind": "method", + "documentation": "emptyDoubleSpliterator(): java.util.Spliterator$OfDouble", + "insertText": "emptyDoubleSpliterator" + }, + { + "label": "emptyIntSpliterator", + "kind": "method", + "documentation": "emptyIntSpliterator(): java.util.Spliterator$OfInt", + "insertText": "emptyIntSpliterator" + }, + { + "label": "emptyLongSpliterator", + "kind": "method", + "documentation": "emptyLongSpliterator(): java.util.Spliterator$OfLong", + "insertText": "emptyLongSpliterator" + }, + { + "label": "emptySpliterator", + "kind": "method", + "documentation": "emptySpliterator(): java.util.Spliterator", + "insertText": "emptySpliterator" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(java.util.Spliterator a): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(java.util.Iterator a, long b, int c | java.util.Collection a, int b): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "spliteratorUnknownSize", + "kind": "method", + "documentation": "spliteratorUnknownSize(java.util.Iterator a, int b): java.util.Spliterator", + "insertText": "spliteratorUnknownSize" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stack", + "kind": "class", + "documentation": "Class: Stack", + "insertText": "Stack", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): boolean", + "insertText": "empty" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(): org.elasticsearch.painless.lookup.def", + "insertText": "peek" + }, + { + "label": "pop", + "kind": "method", + "documentation": "pop(): org.elasticsearch.painless.lookup.def", + "insertText": "pop" + }, + { + "label": "push", + "kind": "method", + "documentation": "push(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "push" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "search", + "kind": "method", + "documentation": "search(org.elasticsearch.painless.lookup.def a): int", + "insertText": "search" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Stack", + "kind": "constructor", + "documentation": "Constructor: Stack", + "insertText": "Stack" + } + }, + { + "label": "StringJoiner", + "kind": "class", + "documentation": "Class: StringJoiner", + "insertText": "StringJoiner", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "add" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "length", + "kind": "method", + "documentation": "length(): int", + "insertText": "length" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(java.util.StringJoiner a): java.util.StringJoiner", + "insertText": "merge" + }, + { + "label": "setEmptyValue", + "kind": "method", + "documentation": "setEmptyValue(java.lang.CharSequence a): java.util.StringJoiner", + "insertText": "setEmptyValue" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringJoiner", + "kind": "constructor", + "documentation": "Constructor: StringJoiner", + "insertText": "StringJoiner" + } + }, + { + "label": "StringTokenizer", + "kind": "class", + "documentation": "Class: StringTokenizer", + "insertText": "StringTokenizer", + "properties": [ + { + "label": "countTokens", + "kind": "method", + "documentation": "countTokens(): int", + "insertText": "countTokens" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hasMoreElements", + "kind": "method", + "documentation": "hasMoreElements(): boolean", + "insertText": "hasMoreElements" + }, + { + "label": "hasMoreTokens", + "kind": "method", + "documentation": "hasMoreTokens(): boolean", + "insertText": "hasMoreTokens" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "nextElement", + "kind": "method", + "documentation": "nextElement(): org.elasticsearch.painless.lookup.def", + "insertText": "nextElement" + }, + { + "label": "nextToken", + "kind": "method", + "documentation": "nextToken(java.lang.String a): java.lang.String", + "insertText": "nextToken" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "StringTokenizer", + "kind": "constructor", + "documentation": "Constructor: StringTokenizer", + "insertText": "StringTokenizer" + } + }, + { + "label": "TimeZone", + "kind": "class", + "documentation": "Class: TimeZone", + "insertText": "TimeZone", + "properties": [ + { + "label": "LONG", + "kind": "property", + "documentation": "LONG: int", + "insertText": "LONG" + }, + { + "label": "SHORT", + "kind": "property", + "documentation": "SHORT: int", + "insertText": "SHORT" + }, + { + "label": "getAvailableIDs", + "kind": "method", + "documentation": "getAvailableIDs(int a): [Ljava.lang.String;", + "insertText": "getAvailableIDs" + }, + { + "label": "getDefault", + "kind": "method", + "documentation": "getDefault(): java.util.TimeZone", + "insertText": "getDefault" + }, + { + "label": "getTimeZone", + "kind": "method", + "documentation": "getTimeZone(java.lang.String a): java.util.TimeZone", + "insertText": "getTimeZone" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDSTSavings", + "kind": "method", + "documentation": "getDSTSavings(): int", + "insertText": "getDSTSavings" + }, + { + "label": "getDisplayName", + "kind": "method", + "documentation": "getDisplayName(boolean a, int b, java.util.Locale c | boolean a, int b | java.util.Locale a): java.lang.String", + "insertText": "getDisplayName" + }, + { + "label": "getID", + "kind": "method", + "documentation": "getID(): java.lang.String", + "insertText": "getID" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(int a, int b, int c, int d, int e, int f | long a): int", + "insertText": "getOffset" + }, + { + "label": "getRawOffset", + "kind": "method", + "documentation": "getRawOffset(): int", + "insertText": "getRawOffset" + }, + { + "label": "hasSameRules", + "kind": "method", + "documentation": "hasSameRules(java.util.TimeZone a): boolean", + "insertText": "hasSameRules" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "inDaylightTime", + "kind": "method", + "documentation": "inDaylightTime(java.util.Date a): boolean", + "insertText": "inDaylightTime" + }, + { + "label": "observesDaylightTime", + "kind": "method", + "documentation": "observesDaylightTime(): boolean", + "insertText": "observesDaylightTime" + }, + { + "label": "setRawOffset", + "kind": "method", + "documentation": "setRawOffset(int a): void", + "insertText": "setRawOffset" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "toZoneId", + "kind": "method", + "documentation": "toZoneId(): java.time.ZoneId", + "insertText": "toZoneId" + }, + { + "label": "useDaylightTime", + "kind": "method", + "documentation": "useDaylightTime(): boolean", + "insertText": "useDaylightTime" + } + ] + }, + { + "label": "TooManyListenersException", + "kind": "class", + "documentation": "Class: TooManyListenersException", + "insertText": "TooManyListenersException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TooManyListenersException", + "kind": "constructor", + "documentation": "Constructor: TooManyListenersException", + "insertText": "TooManyListenersException" + } + }, + { + "label": "TreeMap", + "kind": "class", + "documentation": "Class: TreeMap", + "insertText": "TreeMap", + "properties": [ + { + "label": "ceilingEntry", + "kind": "method", + "documentation": "ceilingEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "ceilingEntry" + }, + { + "label": "ceilingKey", + "kind": "method", + "documentation": "ceilingKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceilingKey" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "compute", + "kind": "method", + "documentation": "compute(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "compute" + }, + { + "label": "computeIfAbsent", + "kind": "method", + "documentation": "computeIfAbsent(org.elasticsearch.painless.lookup.def a, java.util.function.Function b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfAbsent" + }, + { + "label": "computeIfPresent", + "kind": "method", + "documentation": "computeIfPresent(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b): org.elasticsearch.painless.lookup.def", + "insertText": "computeIfPresent" + }, + { + "label": "containsKey", + "kind": "method", + "documentation": "containsKey(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsKey" + }, + { + "label": "containsValue", + "kind": "method", + "documentation": "containsValue(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "containsValue" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(java.util.function.BiPredicate a): int", + "insertText": "count" + }, + { + "label": "descendingKeySet", + "kind": "method", + "documentation": "descendingKeySet(): java.util.NavigableSet", + "insertText": "descendingKeySet" + }, + { + "label": "descendingMap", + "kind": "method", + "documentation": "descendingMap(): java.util.NavigableMap", + "insertText": "descendingMap" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.BiConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "entrySet", + "kind": "method", + "documentation": "entrySet(): java.util.Set", + "insertText": "entrySet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.BiPredicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.BiPredicate a): java.util.Map$Entry", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.BiPredicate a): java.util.Map", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b | java.util.function.BiFunction a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.BiFunction a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstEntry", + "kind": "method", + "documentation": "firstEntry(): java.util.Map$Entry", + "insertText": "firstEntry" + }, + { + "label": "firstKey", + "kind": "method", + "documentation": "firstKey(): org.elasticsearch.painless.lookup.def", + "insertText": "firstKey" + }, + { + "label": "floorEntry", + "kind": "method", + "documentation": "floorEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "floorEntry" + }, + { + "label": "floorKey", + "kind": "method", + "documentation": "floorKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floorKey" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.BiConsumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getOrDefault", + "kind": "method", + "documentation": "getOrDefault(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "getOrDefault" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.BiFunction a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headMap", + "kind": "method", + "documentation": "headMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "headMap" + }, + { + "label": "higherEntry", + "kind": "method", + "documentation": "higherEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "higherEntry" + }, + { + "label": "higherKey", + "kind": "method", + "documentation": "higherKey(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higherKey" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "keySet", + "kind": "method", + "documentation": "keySet(): java.util.Set", + "insertText": "keySet" + }, + { + "label": "lastEntry", + "kind": "method", + "documentation": "lastEntry(): java.util.Map$Entry", + "insertText": "lastEntry" + }, + { + "label": "lastKey", + "kind": "method", + "documentation": "lastKey(): org.elasticsearch.painless.lookup.def", + "insertText": "lastKey" + }, + { + "label": "lowerEntry", + "kind": "method", + "documentation": "lowerEntry(org.elasticsearch.painless.lookup.def a): java.util.Map$Entry", + "insertText": "lowerEntry" + }, + { + "label": "merge", + "kind": "method", + "documentation": "merge(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, java.util.function.BiFunction c): org.elasticsearch.painless.lookup.def", + "insertText": "merge" + }, + { + "label": "navigableKeySet", + "kind": "method", + "documentation": "navigableKeySet(): java.util.NavigableSet", + "insertText": "navigableKeySet" + }, + { + "label": "pollFirstEntry", + "kind": "method", + "documentation": "pollFirstEntry(): java.util.Map$Entry", + "insertText": "pollFirstEntry" + }, + { + "label": "pollLastEntry", + "kind": "method", + "documentation": "pollLastEntry(): java.util.Map$Entry", + "insertText": "pollLastEntry" + }, + { + "label": "put", + "kind": "method", + "documentation": "put(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "put" + }, + { + "label": "putAll", + "kind": "method", + "documentation": "putAll(java.util.Map a): void", + "insertText": "putAll" + }, + { + "label": "putIfAbsent", + "kind": "method", + "documentation": "putIfAbsent(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "putIfAbsent" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "replace", + "kind": "method", + "documentation": "replace(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b, org.elasticsearch.painless.lookup.def c | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean | org.elasticsearch.painless.lookup.def", + "insertText": "replace" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.BiFunction a): void", + "insertText": "replaceAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "subMap", + "kind": "method", + "documentation": "subMap(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableMap | java.util.SortedMap", + "insertText": "subMap" + }, + { + "label": "tailMap", + "kind": "method", + "documentation": "tailMap(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableMap | java.util.SortedMap", + "insertText": "tailMap" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): java.util.Collection", + "insertText": "values" + } + ], + "constructorDefinition": { + "label": "TreeMap", + "kind": "constructor", + "documentation": "Constructor: TreeMap", + "insertText": "TreeMap" + } + }, + { + "label": "TreeSet", + "kind": "class", + "documentation": "Class: TreeSet", + "insertText": "TreeSet", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "ceiling", + "kind": "method", + "documentation": "ceiling(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "ceiling" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "comparator", + "kind": "method", + "documentation": "comparator(): java.util.Comparator", + "insertText": "comparator" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "descendingIterator", + "kind": "method", + "documentation": "descendingIterator(): java.util.Iterator", + "insertText": "descendingIterator" + }, + { + "label": "descendingSet", + "kind": "method", + "documentation": "descendingSet(): java.util.NavigableSet", + "insertText": "descendingSet" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "first", + "kind": "method", + "documentation": "first(): org.elasticsearch.painless.lookup.def", + "insertText": "first" + }, + { + "label": "floor", + "kind": "method", + "documentation": "floor(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "floor" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "headSet", + "kind": "method", + "documentation": "headSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "headSet" + }, + { + "label": "higher", + "kind": "method", + "documentation": "higher(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "higher" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "last", + "kind": "method", + "documentation": "last(): org.elasticsearch.painless.lookup.def", + "insertText": "last" + }, + { + "label": "lower", + "kind": "method", + "documentation": "lower(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "lower" + }, + { + "label": "pollFirst", + "kind": "method", + "documentation": "pollFirst(): org.elasticsearch.painless.lookup.def", + "insertText": "pollFirst" + }, + { + "label": "pollLast", + "kind": "method", + "documentation": "pollLast(): org.elasticsearch.painless.lookup.def", + "insertText": "pollLast" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subSet", + "kind": "method", + "documentation": "subSet(org.elasticsearch.painless.lookup.def a, boolean b, org.elasticsearch.painless.lookup.def c, boolean d | org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): java.util.NavigableSet | java.util.SortedSet", + "insertText": "subSet" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "tailSet", + "kind": "method", + "documentation": "tailSet(org.elasticsearch.painless.lookup.def a, boolean b | org.elasticsearch.painless.lookup.def a): java.util.NavigableSet | java.util.SortedSet", + "insertText": "tailSet" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "TreeSet", + "kind": "constructor", + "documentation": "Constructor: TreeSet", + "insertText": "TreeSet" + } + }, + { + "label": "UUID", + "kind": "class", + "documentation": "Class: UUID", + "insertText": "UUID", + "properties": [ + { + "label": "fromString", + "kind": "method", + "documentation": "fromString(java.lang.String a): java.util.UUID", + "insertText": "fromString" + }, + { + "label": "nameUUIDFromBytes", + "kind": "method", + "documentation": "nameUUIDFromBytes([B a): java.util.UUID", + "insertText": "nameUUIDFromBytes" + }, + { + "label": "randomUUID", + "kind": "method", + "documentation": "randomUUID(): java.util.UUID", + "insertText": "randomUUID" + }, + { + "label": "clockSequence", + "kind": "method", + "documentation": "clockSequence(): int", + "insertText": "clockSequence" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.util.UUID a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLeastSignificantBits", + "kind": "method", + "documentation": "getLeastSignificantBits(): long", + "insertText": "getLeastSignificantBits" + }, + { + "label": "getMostSignificantBits", + "kind": "method", + "documentation": "getMostSignificantBits(): long", + "insertText": "getMostSignificantBits" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "node", + "kind": "method", + "documentation": "node(): long", + "insertText": "node" + }, + { + "label": "timestamp", + "kind": "method", + "documentation": "timestamp(): long", + "insertText": "timestamp" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "variant", + "kind": "method", + "documentation": "variant(): int", + "insertText": "variant" + }, + { + "label": "version", + "kind": "method", + "documentation": "version(): int", + "insertText": "version" + } + ], + "constructorDefinition": { + "label": "UUID", + "kind": "constructor", + "documentation": "Constructor: UUID", + "insertText": "UUID" + } + }, + { + "label": "UnknownFormatConversionException", + "kind": "class", + "documentation": "Class: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getConversion", + "kind": "method", + "documentation": "getConversion(): java.lang.String", + "insertText": "getConversion" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatConversionException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatConversionException", + "insertText": "UnknownFormatConversionException" + } + }, + { + "label": "UnknownFormatFlagsException", + "kind": "class", + "documentation": "Class: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFlags", + "kind": "method", + "documentation": "getFlags(): java.lang.String", + "insertText": "getFlags" + }, + { + "label": "getLocalizedMessage", + "kind": "method", + "documentation": "getLocalizedMessage(): java.lang.String", + "insertText": "getLocalizedMessage" + }, + { + "label": "getMessage", + "kind": "method", + "documentation": "getMessage(): java.lang.String", + "insertText": "getMessage" + }, + { + "label": "getStackTrace", + "kind": "method", + "documentation": "getStackTrace(): [Ljava.lang.StackTraceElement;", + "insertText": "getStackTrace" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "UnknownFormatFlagsException", + "kind": "constructor", + "documentation": "Constructor: UnknownFormatFlagsException", + "insertText": "UnknownFormatFlagsException" + } + }, + { + "label": "Vector", + "kind": "class", + "documentation": "Class: Vector", + "insertText": "Vector", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "addElement", + "kind": "method", + "documentation": "addElement(org.elasticsearch.painless.lookup.def a): void", + "insertText": "addElement" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "clone", + "kind": "method", + "documentation": "clone(): org.elasticsearch.painless.lookup.def", + "insertText": "clone" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "copyInto", + "kind": "method", + "documentation": "copyInto([Ljava.lang.Object; a): void", + "insertText": "copyInto" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "elementAt", + "kind": "method", + "documentation": "elementAt(int a): org.elasticsearch.painless.lookup.def", + "insertText": "elementAt" + }, + { + "label": "elements", + "kind": "method", + "documentation": "elements(): java.util.Enumeration", + "insertText": "elements" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "firstElement", + "kind": "method", + "documentation": "firstElement(): org.elasticsearch.painless.lookup.def", + "insertText": "firstElement" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "insertElementAt", + "kind": "method", + "documentation": "insertElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "insertElementAt" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastElement", + "kind": "method", + "documentation": "lastElement(): org.elasticsearch.painless.lookup.def", + "insertText": "lastElement" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a, int b | org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeAllElements", + "kind": "method", + "documentation": "removeAllElements(): void", + "insertText": "removeAllElements" + }, + { + "label": "removeElement", + "kind": "method", + "documentation": "removeElement(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "removeElement" + }, + { + "label": "removeElementAt", + "kind": "method", + "documentation": "removeElementAt(int a): void", + "insertText": "removeElementAt" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "setElementAt", + "kind": "method", + "documentation": "setElementAt(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "setElementAt" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ], + "constructorDefinition": { + "label": "Vector", + "kind": "constructor", + "documentation": "Constructor: Vector", + "insertText": "Vector" + } + }, + { + "label": "BiConsumer", + "kind": "class", + "documentation": "Class: BiConsumer", + "insertText": "BiConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.BiConsumer a): java.util.function.BiConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiFunction", + "kind": "class", + "documentation": "Class: BiFunction", + "insertText": "BiFunction", + "properties": [ + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BiPredicate", + "kind": "class", + "documentation": "Class: BiPredicate", + "insertText": "BiPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.BiPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.BiPredicate a): java.util.function.BiPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BinaryOperator", + "kind": "class", + "documentation": "Class: BinaryOperator", + "insertText": "BinaryOperator", + "properties": [ + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.function.BinaryOperator", + "insertText": "minBy" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.BiFunction", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BooleanSupplier", + "kind": "class", + "documentation": "Class: BooleanSupplier", + "insertText": "BooleanSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsBoolean", + "kind": "method", + "documentation": "getAsBoolean(): boolean", + "insertText": "getAsBoolean" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Consumer", + "kind": "class", + "documentation": "Class: Consumer", + "insertText": "Consumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleBinaryOperator", + "kind": "class", + "documentation": "Class: DoubleBinaryOperator", + "insertText": "DoubleBinaryOperator", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a, double b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleConsumer", + "kind": "class", + "documentation": "Class: DoubleConsumer", + "insertText": "DoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleFunction", + "kind": "class", + "documentation": "Class: DoubleFunction", + "insertText": "DoubleFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(double a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoublePredicate", + "kind": "class", + "documentation": "Class: DoublePredicate", + "insertText": "DoublePredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.DoublePredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.DoublePredicate a): java.util.function.DoublePredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(double a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleSupplier", + "kind": "class", + "documentation": "Class: DoubleSupplier", + "insertText": "DoubleSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsDouble", + "kind": "method", + "documentation": "getAsDouble(): double", + "insertText": "getAsDouble" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToIntFunction", + "kind": "class", + "documentation": "Class: DoubleToIntFunction", + "insertText": "DoubleToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(double a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleToLongFunction", + "kind": "class", + "documentation": "Class: DoubleToLongFunction", + "insertText": "DoubleToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(double a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleUnaryOperator", + "kind": "class", + "documentation": "Class: DoubleUnaryOperator", + "insertText": "DoubleUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.DoubleUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(double a): double", + "insertText": "applyAsDouble" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.DoubleUnaryOperator a): java.util.function.DoubleUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Function", + "kind": "class", + "documentation": "Class: Function", + "insertText": "Function", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.Function", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntBinaryOperator", + "kind": "class", + "documentation": "Class: IntBinaryOperator", + "insertText": "IntBinaryOperator", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a, int b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntConsumer", + "kind": "class", + "documentation": "Class: IntConsumer", + "insertText": "IntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntFunction", + "kind": "class", + "documentation": "Class: IntFunction", + "insertText": "IntFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(int a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntPredicate", + "kind": "class", + "documentation": "Class: IntPredicate", + "insertText": "IntPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.IntPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.IntPredicate a): java.util.function.IntPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(int a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntSupplier", + "kind": "class", + "documentation": "Class: IntSupplier", + "insertText": "IntSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsInt", + "kind": "method", + "documentation": "getAsInt(): int", + "insertText": "getAsInt" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToDoubleFunction", + "kind": "class", + "documentation": "Class: IntToDoubleFunction", + "insertText": "IntToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(int a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntToLongFunction", + "kind": "class", + "documentation": "Class: IntToLongFunction", + "insertText": "IntToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(int a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntUnaryOperator", + "kind": "class", + "documentation": "Class: IntUnaryOperator", + "insertText": "IntUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.IntUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(int a): int", + "insertText": "applyAsInt" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.IntUnaryOperator a): java.util.function.IntUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongBinaryOperator", + "kind": "class", + "documentation": "Class: LongBinaryOperator", + "insertText": "LongBinaryOperator", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a, long b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongConsumer", + "kind": "class", + "documentation": "Class: LongConsumer", + "insertText": "LongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongFunction", + "kind": "class", + "documentation": "Class: LongFunction", + "insertText": "LongFunction", + "properties": [ + { + "label": "apply", + "kind": "method", + "documentation": "apply(long a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongPredicate", + "kind": "class", + "documentation": "Class: LongPredicate", + "insertText": "LongPredicate", + "properties": [ + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.LongPredicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.LongPredicate a): java.util.function.LongPredicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(long a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongSupplier", + "kind": "class", + "documentation": "Class: LongSupplier", + "insertText": "LongSupplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getAsLong", + "kind": "method", + "documentation": "getAsLong(): long", + "insertText": "getAsLong" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToDoubleFunction", + "kind": "class", + "documentation": "Class: LongToDoubleFunction", + "insertText": "LongToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(long a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongToIntFunction", + "kind": "class", + "documentation": "Class: LongToIntFunction", + "insertText": "LongToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(long a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongUnaryOperator", + "kind": "class", + "documentation": "Class: LongUnaryOperator", + "insertText": "LongUnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.LongUnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "andThen" + }, + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(long a): long", + "insertText": "applyAsLong" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.LongUnaryOperator a): java.util.function.LongUnaryOperator", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjDoubleConsumer", + "kind": "class", + "documentation": "Class: ObjDoubleConsumer", + "insertText": "ObjDoubleConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, double b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjIntConsumer", + "kind": "class", + "documentation": "Class: ObjIntConsumer", + "insertText": "ObjIntConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, int b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ObjLongConsumer", + "kind": "class", + "documentation": "Class: ObjLongConsumer", + "insertText": "ObjLongConsumer", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a, long b): void", + "insertText": "accept" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Predicate", + "kind": "class", + "documentation": "Class: Predicate", + "insertText": "Predicate", + "properties": [ + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(org.elasticsearch.painless.lookup.def a): java.util.function.Predicate", + "insertText": "isEqual" + }, + { + "label": "and", + "kind": "method", + "documentation": "and(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "and" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "negate", + "kind": "method", + "documentation": "negate(): java.util.function.Predicate", + "insertText": "negate" + }, + { + "label": "or", + "kind": "method", + "documentation": "or(java.util.function.Predicate a): java.util.function.Predicate", + "insertText": "or" + }, + { + "label": "test", + "kind": "method", + "documentation": "test(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "test" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Supplier", + "kind": "class", + "documentation": "Class: Supplier", + "insertText": "Supplier", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(): org.elasticsearch.painless.lookup.def", + "insertText": "get" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleBiFunction", + "kind": "class", + "documentation": "Class: ToDoubleBiFunction", + "insertText": "ToDoubleBiFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToDoubleFunction", + "kind": "class", + "documentation": "Class: ToDoubleFunction", + "insertText": "ToDoubleFunction", + "properties": [ + { + "label": "applyAsDouble", + "kind": "method", + "documentation": "applyAsDouble(org.elasticsearch.painless.lookup.def a): double", + "insertText": "applyAsDouble" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntBiFunction", + "kind": "class", + "documentation": "Class: ToIntBiFunction", + "insertText": "ToIntBiFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToIntFunction", + "kind": "class", + "documentation": "Class: ToIntFunction", + "insertText": "ToIntFunction", + "properties": [ + { + "label": "applyAsInt", + "kind": "method", + "documentation": "applyAsInt(org.elasticsearch.painless.lookup.def a): int", + "insertText": "applyAsInt" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongBiFunction", + "kind": "class", + "documentation": "Class: ToLongBiFunction", + "insertText": "ToLongBiFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a, org.elasticsearch.painless.lookup.def b): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ToLongFunction", + "kind": "class", + "documentation": "Class: ToLongFunction", + "insertText": "ToLongFunction", + "properties": [ + { + "label": "applyAsLong", + "kind": "method", + "documentation": "applyAsLong(org.elasticsearch.painless.lookup.def a): long", + "insertText": "applyAsLong" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "UnaryOperator", + "kind": "class", + "documentation": "Class: UnaryOperator", + "insertText": "UnaryOperator", + "properties": [ + { + "label": "identity", + "kind": "method", + "documentation": "identity(): java.util.function.UnaryOperator", + "insertText": "identity" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Function a): java.util.function.Function", + "insertText": "andThen" + }, + { + "label": "apply", + "kind": "method", + "documentation": "apply(org.elasticsearch.painless.lookup.def a): org.elasticsearch.painless.lookup.def", + "insertText": "apply" + }, + { + "label": "compose", + "kind": "method", + "documentation": "compose(java.util.function.Function a): java.util.function.Function", + "insertText": "compose" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Matcher", + "kind": "class", + "documentation": "Class: Matcher", + "insertText": "Matcher", + "properties": [ + { + "label": "quoteReplacement", + "kind": "method", + "documentation": "quoteReplacement(java.lang.String a): java.lang.String", + "insertText": "quoteReplacement" + }, + { + "label": "end", + "kind": "method", + "documentation": "end(int a): int", + "insertText": "end" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(int a): boolean", + "insertText": "find" + }, + { + "label": "group", + "kind": "method", + "documentation": "group(int a): java.lang.String", + "insertText": "group" + }, + { + "label": "groupCount", + "kind": "method", + "documentation": "groupCount(): int", + "insertText": "groupCount" + }, + { + "label": "hasAnchoringBounds", + "kind": "method", + "documentation": "hasAnchoringBounds(): boolean", + "insertText": "hasAnchoringBounds" + }, + { + "label": "hasTransparentBounds", + "kind": "method", + "documentation": "hasTransparentBounds(): boolean", + "insertText": "hasTransparentBounds" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "hitEnd", + "kind": "method", + "documentation": "hitEnd(): boolean", + "insertText": "hitEnd" + }, + { + "label": "lookingAt", + "kind": "method", + "documentation": "lookingAt(): boolean", + "insertText": "lookingAt" + }, + { + "label": "matches", + "kind": "method", + "documentation": "matches(): boolean", + "insertText": "matches" + }, + { + "label": "namedGroup", + "kind": "method", + "documentation": "namedGroup(java.lang.String a): java.lang.String", + "insertText": "namedGroup" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.util.regex.Pattern", + "insertText": "pattern" + }, + { + "label": "region", + "kind": "method", + "documentation": "region(int a, int b): java.util.regex.Matcher", + "insertText": "region" + }, + { + "label": "regionEnd", + "kind": "method", + "documentation": "regionEnd(): int", + "insertText": "regionEnd" + }, + { + "label": "regionStart", + "kind": "method", + "documentation": "regionStart(): int", + "insertText": "regionStart" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.lang.String a): java.lang.String", + "insertText": "replaceAll" + }, + { + "label": "replaceFirst", + "kind": "method", + "documentation": "replaceFirst(java.lang.String a): java.lang.String", + "insertText": "replaceFirst" + }, + { + "label": "requireEnd", + "kind": "method", + "documentation": "requireEnd(): boolean", + "insertText": "requireEnd" + }, + { + "label": "reset", + "kind": "method", + "documentation": "reset(): java.util.regex.Matcher", + "insertText": "reset" + }, + { + "label": "start", + "kind": "method", + "documentation": "start(int a): int", + "insertText": "start" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "useAnchoringBounds", + "kind": "method", + "documentation": "useAnchoringBounds(boolean a): java.util.regex.Matcher", + "insertText": "useAnchoringBounds" + }, + { + "label": "usePattern", + "kind": "method", + "documentation": "usePattern(java.util.regex.Pattern a): java.util.regex.Matcher", + "insertText": "usePattern" + }, + { + "label": "useTransparentBounds", + "kind": "method", + "documentation": "useTransparentBounds(boolean a): java.util.regex.Matcher", + "insertText": "useTransparentBounds" + } + ] + }, + { + "label": "Pattern", + "kind": "class", + "documentation": "Class: Pattern", + "insertText": "Pattern", + "properties": [ + { + "label": "quote", + "kind": "method", + "documentation": "quote(java.lang.String a): java.lang.String", + "insertText": "quote" + }, + { + "label": "asPredicate", + "kind": "method", + "documentation": "asPredicate(): java.util.function.Predicate", + "insertText": "asPredicate" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "flags", + "kind": "method", + "documentation": "flags(): int", + "insertText": "flags" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "matcher", + "kind": "method", + "documentation": "matcher(java.lang.CharSequence a): java.util.regex.Matcher", + "insertText": "matcher" + }, + { + "label": "pattern", + "kind": "method", + "documentation": "pattern(): java.lang.String", + "insertText": "pattern" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.lang.CharSequence a, int b | java.lang.CharSequence a): [Ljava.lang.String;", + "insertText": "split" + }, + { + "label": "splitAsStream", + "kind": "method", + "documentation": "splitAsStream(java.lang.CharSequence a): java.util.stream.Stream", + "insertText": "splitAsStream" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "BaseStream", + "kind": "class", + "documentation": "Class: BaseStream", + "insertText": "BaseStream", + "properties": [ + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Collector", + "kind": "class", + "documentation": "Class: Collector", + "insertText": "Collector", + "properties": [ + { + "label": "of", + "kind": "method", + "documentation": "of(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, java.util.function.Function d, [Ljava.util.stream.Collector$Characteristics; e | java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BinaryOperator c, [Ljava.util.stream.Collector$Characteristics; d): java.util.stream.Collector", + "insertText": "of" + }, + { + "label": "accumulator", + "kind": "method", + "documentation": "accumulator(): java.util.function.BiConsumer", + "insertText": "accumulator" + }, + { + "label": "characteristics", + "kind": "method", + "documentation": "characteristics(): java.util.Set", + "insertText": "characteristics" + }, + { + "label": "combiner", + "kind": "method", + "documentation": "combiner(): java.util.function.BinaryOperator", + "insertText": "combiner" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "finisher", + "kind": "method", + "documentation": "finisher(): java.util.function.Function", + "insertText": "finisher" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "supplier", + "kind": "method", + "documentation": "supplier(): java.util.function.Supplier", + "insertText": "supplier" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collector.Characteristics", + "kind": "class", + "documentation": "Class: Collector.Characteristics", + "insertText": "Collector.Characteristics", + "properties": [ + { + "label": "CONCURRENT", + "kind": "property", + "documentation": "CONCURRENT: java.util.stream.Collector$Characteristics", + "insertText": "CONCURRENT" + }, + { + "label": "IDENTITY_FINISH", + "kind": "property", + "documentation": "IDENTITY_FINISH: java.util.stream.Collector$Characteristics", + "insertText": "IDENTITY_FINISH" + }, + { + "label": "UNORDERED", + "kind": "property", + "documentation": "UNORDERED: java.util.stream.Collector$Characteristics", + "insertText": "UNORDERED" + }, + { + "label": "valueOf", + "kind": "method", + "documentation": "valueOf(java.lang.String a): java.util.stream.Collector$Characteristics", + "insertText": "valueOf" + }, + { + "label": "values", + "kind": "method", + "documentation": "values(): [Ljava.util.stream.Collector$Characteristics;", + "insertText": "values" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.lang.Enum a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "name", + "kind": "method", + "documentation": "name(): java.lang.String", + "insertText": "name" + }, + { + "label": "ordinal", + "kind": "method", + "documentation": "ordinal(): int", + "insertText": "ordinal" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Collectors", + "kind": "class", + "documentation": "Class: Collectors", + "insertText": "Collectors", + "properties": [ + { + "label": "averagingDouble", + "kind": "method", + "documentation": "averagingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "averagingDouble" + }, + { + "label": "averagingInt", + "kind": "method", + "documentation": "averagingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "averagingInt" + }, + { + "label": "averagingLong", + "kind": "method", + "documentation": "averagingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "averagingLong" + }, + { + "label": "collectingAndThen", + "kind": "method", + "documentation": "collectingAndThen(java.util.stream.Collector a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "collectingAndThen" + }, + { + "label": "counting", + "kind": "method", + "documentation": "counting(): java.util.stream.Collector", + "insertText": "counting" + }, + { + "label": "groupingBy", + "kind": "method", + "documentation": "groupingBy(java.util.function.Function a, java.util.function.Supplier b, java.util.stream.Collector c | java.util.function.Function a, java.util.stream.Collector b | java.util.function.Function a): java.util.stream.Collector", + "insertText": "groupingBy" + }, + { + "label": "joining", + "kind": "method", + "documentation": "joining(java.lang.CharSequence a, java.lang.CharSequence b, java.lang.CharSequence c | java.lang.CharSequence a): java.util.stream.Collector", + "insertText": "joining" + }, + { + "label": "mapping", + "kind": "method", + "documentation": "mapping(java.util.function.Function a, java.util.stream.Collector b): java.util.stream.Collector", + "insertText": "mapping" + }, + { + "label": "maxBy", + "kind": "method", + "documentation": "maxBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "maxBy" + }, + { + "label": "minBy", + "kind": "method", + "documentation": "minBy(java.util.Comparator a): java.util.stream.Collector", + "insertText": "minBy" + }, + { + "label": "partitioningBy", + "kind": "method", + "documentation": "partitioningBy(java.util.function.Predicate a, java.util.stream.Collector b | java.util.function.Predicate a): java.util.stream.Collector", + "insertText": "partitioningBy" + }, + { + "label": "reducing", + "kind": "method", + "documentation": "reducing(org.elasticsearch.painless.lookup.def a, java.util.function.Function b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): java.util.stream.Collector", + "insertText": "reducing" + }, + { + "label": "summarizingDouble", + "kind": "method", + "documentation": "summarizingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summarizingDouble" + }, + { + "label": "summarizingInt", + "kind": "method", + "documentation": "summarizingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summarizingInt" + }, + { + "label": "summarizingLong", + "kind": "method", + "documentation": "summarizingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summarizingLong" + }, + { + "label": "summingDouble", + "kind": "method", + "documentation": "summingDouble(java.util.function.ToDoubleFunction a): java.util.stream.Collector", + "insertText": "summingDouble" + }, + { + "label": "summingInt", + "kind": "method", + "documentation": "summingInt(java.util.function.ToIntFunction a): java.util.stream.Collector", + "insertText": "summingInt" + }, + { + "label": "summingLong", + "kind": "method", + "documentation": "summingLong(java.util.function.ToLongFunction a): java.util.stream.Collector", + "insertText": "summingLong" + }, + { + "label": "toCollection", + "kind": "method", + "documentation": "toCollection(java.util.function.Supplier a): java.util.stream.Collector", + "insertText": "toCollection" + }, + { + "label": "toList", + "kind": "method", + "documentation": "toList(): java.util.stream.Collector", + "insertText": "toList" + }, + { + "label": "toMap", + "kind": "method", + "documentation": "toMap(java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c, java.util.function.Supplier d | java.util.function.Function a, java.util.function.Function b, java.util.function.BinaryOperator c | java.util.function.Function a, java.util.function.Function b): java.util.stream.Collector", + "insertText": "toMap" + }, + { + "label": "toSet", + "kind": "method", + "documentation": "toSet(): java.util.stream.Collector", + "insertText": "toSet" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "DoubleStream", + "kind": "class", + "documentation": "Class: DoubleStream", + "insertText": "DoubleStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.DoubleStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.DoubleStream a, java.util.stream.DoubleStream b): java.util.stream.DoubleStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.DoubleStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([D a): java.util.stream.DoubleStream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjDoubleConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.DoubleStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.DoublePredicate a): java.util.stream.DoubleStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalDouble", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalDouble", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.DoubleFunction a): java.util.stream.DoubleStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.DoubleConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.DoubleConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfDouble", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.DoubleStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.DoubleUnaryOperator a): java.util.stream.DoubleStream", + "insertText": "map" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.DoubleToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.DoubleToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.DoubleFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalDouble", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalDouble", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.DoublePredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.DoubleConsumer a): java.util.stream.DoubleStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(double a, java.util.function.DoubleBinaryOperator b | java.util.function.DoubleBinaryOperator a): double | java.util.OptionalDouble", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.DoubleStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.DoubleStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.DoubleStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfDouble", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): double", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.DoubleSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [D", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "DoubleStream.Builder", + "kind": "class", + "documentation": "Class: DoubleStream.Builder", + "insertText": "DoubleStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(double a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(double a): java.util.stream.DoubleStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.DoubleConsumer a): java.util.function.DoubleConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.DoubleStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntStream", + "kind": "class", + "documentation": "Class: IntStream", + "insertText": "IntStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.IntStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.IntStream a, java.util.stream.IntStream b): java.util.stream.IntStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.IntStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([I a): java.util.stream.IntStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(int a, int b): java.util.stream.IntStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(int a, int b): java.util.stream.IntStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.IntPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.IntPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "asLongStream", + "kind": "method", + "documentation": "asLongStream(): java.util.stream.LongStream", + "insertText": "asLongStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjIntConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.IntStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.IntPredicate a): java.util.stream.IntStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalInt", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalInt", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.IntFunction a): java.util.stream.IntStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.IntConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.IntConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfInt", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.IntStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.IntUnaryOperator a): java.util.stream.IntStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.IntToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.IntToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.IntFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalInt", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalInt", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.IntPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.IntConsumer a): java.util.stream.IntStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(int a, java.util.function.IntBinaryOperator b | java.util.function.IntBinaryOperator a): int | java.util.OptionalInt", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.IntStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.IntStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.IntStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfInt", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): int", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.IntSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [I", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "IntStream.Builder", + "kind": "class", + "documentation": "Class: IntStream.Builder", + "insertText": "IntStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(int a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(int a): java.util.stream.IntStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.IntConsumer a): java.util.function.IntConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.IntStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "LongStream", + "kind": "class", + "documentation": "Class: LongStream", + "insertText": "LongStream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.LongStream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.LongStream a, java.util.stream.LongStream b): java.util.stream.LongStream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.LongStream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([J a): java.util.stream.LongStream", + "insertText": "of" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(long a, long b): java.util.stream.LongStream", + "insertText": "range" + }, + { + "label": "rangeClosed", + "kind": "method", + "documentation": "rangeClosed(long a, long b): java.util.stream.LongStream", + "insertText": "rangeClosed" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.LongPredicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.LongPredicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "asDoubleStream", + "kind": "method", + "documentation": "asDoubleStream(): java.util.stream.DoubleStream", + "insertText": "asDoubleStream" + }, + { + "label": "average", + "kind": "method", + "documentation": "average(): java.util.OptionalDouble", + "insertText": "average" + }, + { + "label": "boxed", + "kind": "method", + "documentation": "boxed(): java.util.stream.Stream", + "insertText": "boxed" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.ObjLongConsumer b, java.util.function.BiConsumer c): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.LongStream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.LongPredicate a): java.util.stream.LongStream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.OptionalLong", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.OptionalLong", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.LongFunction a): java.util.stream.LongStream", + "insertText": "flatMap" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.LongConsumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.LongConsumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.PrimitiveIterator$OfLong", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.LongStream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.LongUnaryOperator a): java.util.stream.LongStream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.LongToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.LongToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToObj", + "kind": "method", + "documentation": "mapToObj(java.util.function.LongFunction a): java.util.stream.Stream", + "insertText": "mapToObj" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(): java.util.OptionalLong", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(): java.util.OptionalLong", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.LongPredicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.LongConsumer a): java.util.stream.LongStream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(long a, java.util.function.LongBinaryOperator b | java.util.function.LongBinaryOperator a): long | java.util.OptionalLong", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.LongStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.LongStream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(): java.util.stream.LongStream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator$OfLong", + "insertText": "spliterator" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(): long", + "insertText": "sum" + }, + { + "label": "summaryStatistics", + "kind": "method", + "documentation": "summaryStatistics(): java.util.LongSummaryStatistics", + "insertText": "summaryStatistics" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(): [J", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "LongStream.Builder", + "kind": "class", + "documentation": "Class: LongStream.Builder", + "insertText": "LongStream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(long a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(long a): java.util.stream.LongStream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.LongConsumer a): java.util.function.LongConsumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.LongStream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Stream", + "kind": "class", + "documentation": "Class: Stream", + "insertText": "Stream", + "properties": [ + { + "label": "builder", + "kind": "method", + "documentation": "builder(): java.util.stream.Stream$Builder", + "insertText": "builder" + }, + { + "label": "concat", + "kind": "method", + "documentation": "concat(java.util.stream.Stream a, java.util.stream.Stream b): java.util.stream.Stream", + "insertText": "concat" + }, + { + "label": "empty", + "kind": "method", + "documentation": "empty(): java.util.stream.Stream", + "insertText": "empty" + }, + { + "label": "of", + "kind": "method", + "documentation": "of([Lorg.elasticsearch.painless.lookup.def; a): java.util.stream.Stream", + "insertText": "of" + }, + { + "label": "allMatch", + "kind": "method", + "documentation": "allMatch(java.util.function.Predicate a): boolean", + "insertText": "allMatch" + }, + { + "label": "anyMatch", + "kind": "method", + "documentation": "anyMatch(java.util.function.Predicate a): boolean", + "insertText": "anyMatch" + }, + { + "label": "close", + "kind": "method", + "documentation": "close(): void", + "insertText": "close" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.function.Supplier a, java.util.function.BiConsumer b, java.util.function.BiConsumer c | java.util.stream.Collector a): org.elasticsearch.painless.lookup.def", + "insertText": "collect" + }, + { + "label": "count", + "kind": "method", + "documentation": "count(): long", + "insertText": "count" + }, + { + "label": "distinct", + "kind": "method", + "documentation": "distinct(): java.util.stream.Stream", + "insertText": "distinct" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "filter", + "kind": "method", + "documentation": "filter(java.util.function.Predicate a): java.util.stream.Stream", + "insertText": "filter" + }, + { + "label": "findAny", + "kind": "method", + "documentation": "findAny(): java.util.Optional", + "insertText": "findAny" + }, + { + "label": "findFirst", + "kind": "method", + "documentation": "findFirst(): java.util.Optional", + "insertText": "findFirst" + }, + { + "label": "flatMap", + "kind": "method", + "documentation": "flatMap(java.util.function.Function a): java.util.stream.Stream", + "insertText": "flatMap" + }, + { + "label": "flatMapToDouble", + "kind": "method", + "documentation": "flatMapToDouble(java.util.function.Function a): java.util.stream.DoubleStream", + "insertText": "flatMapToDouble" + }, + { + "label": "flatMapToInt", + "kind": "method", + "documentation": "flatMapToInt(java.util.function.Function a): java.util.stream.IntStream", + "insertText": "flatMapToInt" + }, + { + "label": "flatMapToLong", + "kind": "method", + "documentation": "flatMapToLong(java.util.function.Function a): java.util.stream.LongStream", + "insertText": "flatMapToLong" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "forEachOrdered", + "kind": "method", + "documentation": "forEachOrdered(java.util.function.Consumer a): void", + "insertText": "forEachOrdered" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isParallel", + "kind": "method", + "documentation": "isParallel(): boolean", + "insertText": "isParallel" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "limit", + "kind": "method", + "documentation": "limit(long a): java.util.stream.Stream", + "insertText": "limit" + }, + { + "label": "map", + "kind": "method", + "documentation": "map(java.util.function.Function a): java.util.stream.Stream", + "insertText": "map" + }, + { + "label": "mapToDouble", + "kind": "method", + "documentation": "mapToDouble(java.util.function.ToDoubleFunction a): java.util.stream.DoubleStream", + "insertText": "mapToDouble" + }, + { + "label": "mapToInt", + "kind": "method", + "documentation": "mapToInt(java.util.function.ToIntFunction a): java.util.stream.IntStream", + "insertText": "mapToInt" + }, + { + "label": "mapToLong", + "kind": "method", + "documentation": "mapToLong(java.util.function.ToLongFunction a): java.util.stream.LongStream", + "insertText": "mapToLong" + }, + { + "label": "max", + "kind": "method", + "documentation": "max(java.util.Comparator a): java.util.Optional", + "insertText": "max" + }, + { + "label": "min", + "kind": "method", + "documentation": "min(java.util.Comparator a): java.util.Optional", + "insertText": "min" + }, + { + "label": "noneMatch", + "kind": "method", + "documentation": "noneMatch(java.util.function.Predicate a): boolean", + "insertText": "noneMatch" + }, + { + "label": "peek", + "kind": "method", + "documentation": "peek(java.util.function.Consumer a): java.util.stream.Stream", + "insertText": "peek" + }, + { + "label": "reduce", + "kind": "method", + "documentation": "reduce(org.elasticsearch.painless.lookup.def a, java.util.function.BiFunction b, java.util.function.BinaryOperator c | org.elasticsearch.painless.lookup.def a, java.util.function.BinaryOperator b | java.util.function.BinaryOperator a): org.elasticsearch.painless.lookup.def | java.util.Optional", + "insertText": "reduce" + }, + { + "label": "sequential", + "kind": "method", + "documentation": "sequential(): java.util.stream.BaseStream", + "insertText": "sequential" + }, + { + "label": "skip", + "kind": "method", + "documentation": "skip(long a): java.util.stream.Stream", + "insertText": "skip" + }, + { + "label": "sorted", + "kind": "method", + "documentation": "sorted(java.util.Comparator a): java.util.stream.Stream", + "insertText": "sorted" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray(java.util.function.IntFunction a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "unordered", + "kind": "method", + "documentation": "unordered(): java.util.stream.BaseStream", + "insertText": "unordered" + } + ] + }, + { + "label": "Stream.Builder", + "kind": "class", + "documentation": "Class: Stream.Builder", + "insertText": "Stream.Builder", + "properties": [ + { + "label": "accept", + "kind": "method", + "documentation": "accept(org.elasticsearch.painless.lookup.def a): void", + "insertText": "accept" + }, + { + "label": "add", + "kind": "method", + "documentation": "add(org.elasticsearch.painless.lookup.def a): java.util.stream.Stream$Builder", + "insertText": "add" + }, + { + "label": "andThen", + "kind": "method", + "documentation": "andThen(java.util.function.Consumer a): java.util.function.Consumer", + "insertText": "andThen" + }, + { + "label": "build", + "kind": "method", + "documentation": "build(): java.util.stream.Stream", + "insertText": "build" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "long", + "kind": "type", + "documentation": "Primitive: long", + "insertText": "long" + }, + { + "label": "BytesRef", + "kind": "class", + "documentation": "Class: BytesRef", + "insertText": "BytesRef", + "properties": [ + { + "label": "bytesEquals", + "kind": "method", + "documentation": "bytesEquals(org.apache.lucene.util.BytesRef a): boolean", + "insertText": "bytesEquals" + }, + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(org.elasticsearch.painless.lookup.def a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + }, + { + "label": "utf8ToString", + "kind": "method", + "documentation": "utf8ToString(): java.lang.String", + "insertText": "utf8ToString" + }, + { + "label": "bytes", + "kind": "property", + "documentation": "bytes: [B", + "insertText": "bytes" + }, + { + "label": "length", + "kind": "property", + "documentation": "length: int", + "insertText": "length" + }, + { + "label": "offset", + "kind": "property", + "documentation": "offset: int", + "insertText": "offset" + } + ] + }, + { + "label": "GeoPoint", + "kind": "class", + "documentation": "Class: GeoPoint", + "insertText": "GeoPoint", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Booleans", + "kind": "class", + "documentation": "Class: ScriptDocValues.Booleans", + "insertText": "ScriptDocValues.Booleans", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Boolean", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): boolean", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.BytesRefs", + "kind": "class", + "documentation": "Class: ScriptDocValues.BytesRefs", + "insertText": "ScriptDocValues.BytesRefs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.apache.lucene.util.BytesRef", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.apache.lucene.util.BytesRef", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Dates", + "kind": "class", + "documentation": "Class: ScriptDocValues.Dates", + "insertText": "ScriptDocValues.Dates", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.script.JodaCompatibleZonedDateTime", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Doubles", + "kind": "class", + "documentation": "Class: ScriptDocValues.Doubles", + "insertText": "ScriptDocValues.Doubles", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Double", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): double", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.GeoPoints", + "kind": "class", + "documentation": "Class: ScriptDocValues.GeoPoints", + "insertText": "ScriptDocValues.GeoPoints", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "arcDistance", + "kind": "method", + "documentation": "arcDistance(double a, double b): double", + "insertText": "arcDistance" + }, + { + "label": "arcDistanceWithDefault", + "kind": "method", + "documentation": "arcDistanceWithDefault(double a, double b, double c): double", + "insertText": "arcDistanceWithDefault" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "geohashDistance", + "kind": "method", + "documentation": "geohashDistance(java.lang.String a): double", + "insertText": "geohashDistance" + }, + { + "label": "geohashDistanceWithDefault", + "kind": "method", + "documentation": "geohashDistanceWithDefault(java.lang.String a, double b): double", + "insertText": "geohashDistanceWithDefault" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): org.elasticsearch.common.geo.GeoPoint", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLat", + "kind": "method", + "documentation": "getLat(): double", + "insertText": "getLat" + }, + { + "label": "getLats", + "kind": "method", + "documentation": "getLats(): [D", + "insertText": "getLats" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getLon", + "kind": "method", + "documentation": "getLon(): double", + "insertText": "getLon" + }, + { + "label": "getLons", + "kind": "method", + "documentation": "getLons(): [D", + "insertText": "getLons" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.common.geo.GeoPoint", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "planeDistance", + "kind": "method", + "documentation": "planeDistance(double a, double b): double", + "insertText": "planeDistance" + }, + { + "label": "planeDistanceWithDefault", + "kind": "method", + "documentation": "planeDistanceWithDefault(double a, double b, double c): double", + "insertText": "planeDistanceWithDefault" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Longs", + "kind": "class", + "documentation": "Class: ScriptDocValues.Longs", + "insertText": "ScriptDocValues.Longs", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.Long", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): long", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptDocValues.Strings", + "kind": "class", + "documentation": "Class: ScriptDocValues.Strings", + "insertText": "ScriptDocValues.Strings", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "kind": "class", + "documentation": "Class: IpFieldMapper.IpFieldType$IpScriptDocValues", + "insertText": "IpFieldMapper.IpFieldType$IpScriptDocValues", + "properties": [ + { + "label": "add", + "kind": "method", + "documentation": "add(int a, org.elasticsearch.painless.lookup.def b | org.elasticsearch.painless.lookup.def a): void | boolean", + "insertText": "add" + }, + { + "label": "addAll", + "kind": "method", + "documentation": "addAll(int a, java.util.Collection b | java.util.Collection a): boolean", + "insertText": "addAll" + }, + { + "label": "any", + "kind": "method", + "documentation": "any(java.util.function.Predicate a): boolean", + "insertText": "any" + }, + { + "label": "asCollection", + "kind": "method", + "documentation": "asCollection(): java.util.Collection", + "insertText": "asCollection" + }, + { + "label": "asList", + "kind": "method", + "documentation": "asList(): java.util.List", + "insertText": "asList" + }, + { + "label": "clear", + "kind": "method", + "documentation": "clear(): void", + "insertText": "clear" + }, + { + "label": "collect", + "kind": "method", + "documentation": "collect(java.util.Collection a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def | java.util.List", + "insertText": "collect" + }, + { + "label": "contains", + "kind": "method", + "documentation": "contains(org.elasticsearch.painless.lookup.def a): boolean", + "insertText": "contains" + }, + { + "label": "containsAll", + "kind": "method", + "documentation": "containsAll(java.util.Collection a): boolean", + "insertText": "containsAll" + }, + { + "label": "each", + "kind": "method", + "documentation": "each(java.util.function.Consumer a): org.elasticsearch.painless.lookup.def", + "insertText": "each" + }, + { + "label": "eachWithIndex", + "kind": "method", + "documentation": "eachWithIndex(java.util.function.ObjIntConsumer a): org.elasticsearch.painless.lookup.def", + "insertText": "eachWithIndex" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "every", + "kind": "method", + "documentation": "every(java.util.function.Predicate a): boolean", + "insertText": "every" + }, + { + "label": "find", + "kind": "method", + "documentation": "find(java.util.function.Predicate a): org.elasticsearch.painless.lookup.def", + "insertText": "find" + }, + { + "label": "findAll", + "kind": "method", + "documentation": "findAll(java.util.function.Predicate a): java.util.List", + "insertText": "findAll" + }, + { + "label": "findResult", + "kind": "method", + "documentation": "findResult(org.elasticsearch.painless.lookup.def a, java.util.function.Function b | java.util.function.Function a): org.elasticsearch.painless.lookup.def", + "insertText": "findResult" + }, + { + "label": "findResults", + "kind": "method", + "documentation": "findResults(java.util.function.Function a): java.util.List", + "insertText": "findResults" + }, + { + "label": "forEach", + "kind": "method", + "documentation": "forEach(java.util.function.Consumer a): void", + "insertText": "forEach" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(int a): java.lang.String", + "insertText": "get" + }, + { + "label": "getByPath", + "kind": "method", + "documentation": "getByPath(java.lang.String a, java.lang.Object b | java.lang.String a): java.lang.Object", + "insertText": "getByPath" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): java.lang.String", + "insertText": "getValue" + }, + { + "label": "groupBy", + "kind": "method", + "documentation": "groupBy(java.util.function.Function a): java.util.Map", + "insertText": "groupBy" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "indexOf", + "kind": "method", + "documentation": "indexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "indexOf" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "iterator", + "kind": "method", + "documentation": "iterator(): java.util.Iterator", + "insertText": "iterator" + }, + { + "label": "join", + "kind": "method", + "documentation": "join(java.lang.String a): java.lang.String", + "insertText": "join" + }, + { + "label": "lastIndexOf", + "kind": "method", + "documentation": "lastIndexOf(org.elasticsearch.painless.lookup.def a): int", + "insertText": "lastIndexOf" + }, + { + "label": "listIterator", + "kind": "method", + "documentation": "listIterator(int a): java.util.ListIterator", + "insertText": "listIterator" + }, + { + "label": "remove", + "kind": "method", + "documentation": "remove(int a): org.elasticsearch.painless.lookup.def", + "insertText": "remove" + }, + { + "label": "removeAll", + "kind": "method", + "documentation": "removeAll(java.util.Collection a): boolean", + "insertText": "removeAll" + }, + { + "label": "removeIf", + "kind": "method", + "documentation": "removeIf(java.util.function.Predicate a): boolean", + "insertText": "removeIf" + }, + { + "label": "replaceAll", + "kind": "method", + "documentation": "replaceAll(java.util.function.UnaryOperator a): void", + "insertText": "replaceAll" + }, + { + "label": "retainAll", + "kind": "method", + "documentation": "retainAll(java.util.Collection a): boolean", + "insertText": "retainAll" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(int a, org.elasticsearch.painless.lookup.def b): org.elasticsearch.painless.lookup.def", + "insertText": "set" + }, + { + "label": "size", + "kind": "method", + "documentation": "size(): int", + "insertText": "size" + }, + { + "label": "sort", + "kind": "method", + "documentation": "sort(java.util.Comparator a): void", + "insertText": "sort" + }, + { + "label": "split", + "kind": "method", + "documentation": "split(java.util.function.Predicate a): java.util.List", + "insertText": "split" + }, + { + "label": "spliterator", + "kind": "method", + "documentation": "spliterator(): java.util.Spliterator", + "insertText": "spliterator" + }, + { + "label": "stream", + "kind": "method", + "documentation": "stream(): java.util.stream.Stream", + "insertText": "stream" + }, + { + "label": "subList", + "kind": "method", + "documentation": "subList(int a, int b): java.util.List", + "insertText": "subList" + }, + { + "label": "sum", + "kind": "method", + "documentation": "sum(java.util.function.ToDoubleFunction a): double", + "insertText": "sum" + }, + { + "label": "toArray", + "kind": "method", + "documentation": "toArray([Lorg.elasticsearch.painless.lookup.def; a): [Lorg.elasticsearch.painless.lookup.def;", + "insertText": "toArray" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "IntervalFilterScript.Interval", + "kind": "class", + "documentation": "Class: IntervalFilterScript.Interval", + "insertText": "IntervalFilterScript.Interval", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getEnd", + "kind": "method", + "documentation": "getEnd(): int", + "insertText": "getEnd" + }, + { + "label": "getGaps", + "kind": "method", + "documentation": "getGaps(): int", + "insertText": "getGaps" + }, + { + "label": "getStart", + "kind": "method", + "documentation": "getStart(): int", + "insertText": "getStart" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Doc", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Doc", + "insertText": "ScriptedSimilarity.Doc", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getFreq", + "kind": "method", + "documentation": "getFreq(): float", + "insertText": "getFreq" + }, + { + "label": "getLength", + "kind": "method", + "documentation": "getLength(): int", + "insertText": "getLength" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Field", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Field", + "insertText": "ScriptedSimilarity.Field", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocCount", + "kind": "method", + "documentation": "getDocCount(): long", + "insertText": "getDocCount" + }, + { + "label": "getSumDocFreq", + "kind": "method", + "documentation": "getSumDocFreq(): long", + "insertText": "getSumDocFreq" + }, + { + "label": "getSumTotalTermFreq", + "kind": "method", + "documentation": "getSumTotalTermFreq(): long", + "insertText": "getSumTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Query", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Query", + "insertText": "ScriptedSimilarity.Query", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getBoost", + "kind": "method", + "documentation": "getBoost(): float", + "insertText": "getBoost" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "ScriptedSimilarity.Term", + "kind": "class", + "documentation": "Class: ScriptedSimilarity.Term", + "insertText": "ScriptedSimilarity.Term", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getDocFreq", + "kind": "method", + "documentation": "getDocFreq(): long", + "insertText": "getDocFreq" + }, + { + "label": "getTotalTermFreq", + "kind": "method", + "documentation": "getTotalTermFreq(): long", + "insertText": "getTotalTermFreq" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "Debug", + "kind": "class", + "documentation": "Class: Debug", + "insertText": "Debug", + "properties": [ + { + "label": "explain", + "kind": "method", + "documentation": "explain(java.lang.Object a): void", + "insertText": "explain" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "JodaCompatibleZonedDateTime", + "kind": "class", + "documentation": "Class: JodaCompatibleZonedDateTime", + "insertText": "JodaCompatibleZonedDateTime", + "properties": [ + { + "label": "compareTo", + "kind": "method", + "documentation": "compareTo(java.time.chrono.ChronoZonedDateTime a): int", + "insertText": "compareTo" + }, + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "format", + "kind": "method", + "documentation": "format(java.time.format.DateTimeFormatter a): java.lang.String", + "insertText": "format" + }, + { + "label": "get", + "kind": "method", + "documentation": "get(java.time.temporal.TemporalField a): int", + "insertText": "get" + }, + { + "label": "getCenturyOfEra", + "kind": "method", + "documentation": "getCenturyOfEra(): int", + "insertText": "getCenturyOfEra" + }, + { + "label": "getChronology", + "kind": "method", + "documentation": "getChronology(): java.time.chrono.Chronology", + "insertText": "getChronology" + }, + { + "label": "getDayOfMonth", + "kind": "method", + "documentation": "getDayOfMonth(): int", + "insertText": "getDayOfMonth" + }, + { + "label": "getDayOfWeek", + "kind": "method", + "documentation": "getDayOfWeek(): int", + "insertText": "getDayOfWeek" + }, + { + "label": "getDayOfWeekEnum", + "kind": "method", + "documentation": "getDayOfWeekEnum(): java.time.DayOfWeek", + "insertText": "getDayOfWeekEnum" + }, + { + "label": "getDayOfYear", + "kind": "method", + "documentation": "getDayOfYear(): int", + "insertText": "getDayOfYear" + }, + { + "label": "getEra", + "kind": "method", + "documentation": "getEra(): int", + "insertText": "getEra" + }, + { + "label": "getHour", + "kind": "method", + "documentation": "getHour(): int", + "insertText": "getHour" + }, + { + "label": "getHourOfDay", + "kind": "method", + "documentation": "getHourOfDay(): int", + "insertText": "getHourOfDay" + }, + { + "label": "getLong", + "kind": "method", + "documentation": "getLong(java.time.temporal.TemporalField a): long", + "insertText": "getLong" + }, + { + "label": "getMillis", + "kind": "method", + "documentation": "getMillis(): long", + "insertText": "getMillis" + }, + { + "label": "getMillisOfDay", + "kind": "method", + "documentation": "getMillisOfDay(): int", + "insertText": "getMillisOfDay" + }, + { + "label": "getMillisOfSecond", + "kind": "method", + "documentation": "getMillisOfSecond(): int", + "insertText": "getMillisOfSecond" + }, + { + "label": "getMinute", + "kind": "method", + "documentation": "getMinute(): int", + "insertText": "getMinute" + }, + { + "label": "getMinuteOfDay", + "kind": "method", + "documentation": "getMinuteOfDay(): int", + "insertText": "getMinuteOfDay" + }, + { + "label": "getMinuteOfHour", + "kind": "method", + "documentation": "getMinuteOfHour(): int", + "insertText": "getMinuteOfHour" + }, + { + "label": "getMonth", + "kind": "method", + "documentation": "getMonth(): java.time.Month", + "insertText": "getMonth" + }, + { + "label": "getMonthOfYear", + "kind": "method", + "documentation": "getMonthOfYear(): int", + "insertText": "getMonthOfYear" + }, + { + "label": "getMonthValue", + "kind": "method", + "documentation": "getMonthValue(): int", + "insertText": "getMonthValue" + }, + { + "label": "getNano", + "kind": "method", + "documentation": "getNano(): int", + "insertText": "getNano" + }, + { + "label": "getOffset", + "kind": "method", + "documentation": "getOffset(): java.time.ZoneOffset", + "insertText": "getOffset" + }, + { + "label": "getSecond", + "kind": "method", + "documentation": "getSecond(): int", + "insertText": "getSecond" + }, + { + "label": "getSecondOfDay", + "kind": "method", + "documentation": "getSecondOfDay(): int", + "insertText": "getSecondOfDay" + }, + { + "label": "getSecondOfMinute", + "kind": "method", + "documentation": "getSecondOfMinute(): int", + "insertText": "getSecondOfMinute" + }, + { + "label": "getWeekOfWeekyear", + "kind": "method", + "documentation": "getWeekOfWeekyear(): int", + "insertText": "getWeekOfWeekyear" + }, + { + "label": "getWeekyear", + "kind": "method", + "documentation": "getWeekyear(): int", + "insertText": "getWeekyear" + }, + { + "label": "getYear", + "kind": "method", + "documentation": "getYear(): int", + "insertText": "getYear" + }, + { + "label": "getYearOfCentury", + "kind": "method", + "documentation": "getYearOfCentury(): int", + "insertText": "getYearOfCentury" + }, + { + "label": "getYearOfEra", + "kind": "method", + "documentation": "getYearOfEra(): int", + "insertText": "getYearOfEra" + }, + { + "label": "getZone", + "kind": "method", + "documentation": "getZone(): java.time.ZoneId", + "insertText": "getZone" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isAfter", + "kind": "method", + "documentation": "isAfter(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isAfter" + }, + { + "label": "isBefore", + "kind": "method", + "documentation": "isBefore(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isBefore" + }, + { + "label": "isEqual", + "kind": "method", + "documentation": "isEqual(java.time.chrono.ChronoZonedDateTime a): boolean", + "insertText": "isEqual" + }, + { + "label": "isSupported", + "kind": "method", + "documentation": "isSupported(java.time.temporal.TemporalField a): boolean", + "insertText": "isSupported" + }, + { + "label": "minus", + "kind": "method", + "documentation": "minus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "minus" + }, + { + "label": "minusDays", + "kind": "method", + "documentation": "minusDays(long a): java.time.ZonedDateTime", + "insertText": "minusDays" + }, + { + "label": "minusHours", + "kind": "method", + "documentation": "minusHours(long a): java.time.ZonedDateTime", + "insertText": "minusHours" + }, + { + "label": "minusMinutes", + "kind": "method", + "documentation": "minusMinutes(long a): java.time.ZonedDateTime", + "insertText": "minusMinutes" + }, + { + "label": "minusMonths", + "kind": "method", + "documentation": "minusMonths(long a): java.time.ZonedDateTime", + "insertText": "minusMonths" + }, + { + "label": "minusNanos", + "kind": "method", + "documentation": "minusNanos(long a): java.time.ZonedDateTime", + "insertText": "minusNanos" + }, + { + "label": "minusSeconds", + "kind": "method", + "documentation": "minusSeconds(long a): java.time.ZonedDateTime", + "insertText": "minusSeconds" + }, + { + "label": "minusWeeks", + "kind": "method", + "documentation": "minusWeeks(long a): java.time.ZonedDateTime", + "insertText": "minusWeeks" + }, + { + "label": "minusYears", + "kind": "method", + "documentation": "minusYears(long a): java.time.ZonedDateTime", + "insertText": "minusYears" + }, + { + "label": "plus", + "kind": "method", + "documentation": "plus(long a, java.time.temporal.TemporalUnit b | java.time.temporal.TemporalAmount a): java.time.ZonedDateTime", + "insertText": "plus" + }, + { + "label": "plusDays", + "kind": "method", + "documentation": "plusDays(long a): java.time.ZonedDateTime", + "insertText": "plusDays" + }, + { + "label": "plusHours", + "kind": "method", + "documentation": "plusHours(long a): java.time.ZonedDateTime", + "insertText": "plusHours" + }, + { + "label": "plusMinutes", + "kind": "method", + "documentation": "plusMinutes(long a): java.time.ZonedDateTime", + "insertText": "plusMinutes" + }, + { + "label": "plusMonths", + "kind": "method", + "documentation": "plusMonths(long a): java.time.ZonedDateTime", + "insertText": "plusMonths" + }, + { + "label": "plusNanos", + "kind": "method", + "documentation": "plusNanos(long a): java.time.ZonedDateTime", + "insertText": "plusNanos" + }, + { + "label": "plusSeconds", + "kind": "method", + "documentation": "plusSeconds(long a): java.time.ZonedDateTime", + "insertText": "plusSeconds" + }, + { + "label": "plusWeeks", + "kind": "method", + "documentation": "plusWeeks(long a): java.time.ZonedDateTime", + "insertText": "plusWeeks" + }, + { + "label": "plusYears", + "kind": "method", + "documentation": "plusYears(long a): java.time.ZonedDateTime", + "insertText": "plusYears" + }, + { + "label": "query", + "kind": "method", + "documentation": "query(java.time.temporal.TemporalQuery a): org.elasticsearch.painless.lookup.def", + "insertText": "query" + }, + { + "label": "range", + "kind": "method", + "documentation": "range(java.time.temporal.TemporalField a): java.time.temporal.ValueRange", + "insertText": "range" + }, + { + "label": "toEpochMilli", + "kind": "method", + "documentation": "toEpochMilli(): long", + "insertText": "toEpochMilli" + }, + { + "label": "toEpochSecond", + "kind": "method", + "documentation": "toEpochSecond(): long", + "insertText": "toEpochSecond" + }, + { + "label": "toInstant", + "kind": "method", + "documentation": "toInstant(): java.time.Instant", + "insertText": "toInstant" + }, + { + "label": "toLocalDate", + "kind": "method", + "documentation": "toLocalDate(): java.time.LocalDate", + "insertText": "toLocalDate" + }, + { + "label": "toLocalDateTime", + "kind": "method", + "documentation": "toLocalDateTime(): java.time.LocalDateTime", + "insertText": "toLocalDateTime" + }, + { + "label": "toLocalTime", + "kind": "method", + "documentation": "toLocalTime(): java.time.LocalTime", + "insertText": "toLocalTime" + }, + { + "label": "toOffsetDateTime", + "kind": "method", + "documentation": "toOffsetDateTime(): java.time.OffsetDateTime", + "insertText": "toOffsetDateTime" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(java.lang.String a, java.util.Locale b | java.lang.String a): java.lang.String", + "insertText": "toString" + }, + { + "label": "truncatedTo", + "kind": "method", + "documentation": "truncatedTo(java.time.temporal.TemporalUnit a): java.time.ZonedDateTime", + "insertText": "truncatedTo" + }, + { + "label": "until", + "kind": "method", + "documentation": "until(java.time.temporal.Temporal a, java.time.temporal.TemporalUnit b): long", + "insertText": "until" + }, + { + "label": "with", + "kind": "method", + "documentation": "with(java.time.temporal.TemporalField a, long b | java.time.temporal.TemporalAdjuster a): java.time.ZonedDateTime", + "insertText": "with" + }, + { + "label": "withDayOfMonth", + "kind": "method", + "documentation": "withDayOfMonth(int a): java.time.ZonedDateTime", + "insertText": "withDayOfMonth" + }, + { + "label": "withDayOfYear", + "kind": "method", + "documentation": "withDayOfYear(int a): java.time.ZonedDateTime", + "insertText": "withDayOfYear" + }, + { + "label": "withEarlierOffsetAtOverlap", + "kind": "method", + "documentation": "withEarlierOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withEarlierOffsetAtOverlap" + }, + { + "label": "withFixedOffsetZone", + "kind": "method", + "documentation": "withFixedOffsetZone(): java.time.ZonedDateTime", + "insertText": "withFixedOffsetZone" + }, + { + "label": "withHour", + "kind": "method", + "documentation": "withHour(int a): java.time.ZonedDateTime", + "insertText": "withHour" + }, + { + "label": "withLaterOffsetAtOverlap", + "kind": "method", + "documentation": "withLaterOffsetAtOverlap(): java.time.ZonedDateTime", + "insertText": "withLaterOffsetAtOverlap" + }, + { + "label": "withMinute", + "kind": "method", + "documentation": "withMinute(int a): java.time.ZonedDateTime", + "insertText": "withMinute" + }, + { + "label": "withMonth", + "kind": "method", + "documentation": "withMonth(int a): java.time.ZonedDateTime", + "insertText": "withMonth" + }, + { + "label": "withNano", + "kind": "method", + "documentation": "withNano(int a): java.time.ZonedDateTime", + "insertText": "withNano" + }, + { + "label": "withSecond", + "kind": "method", + "documentation": "withSecond(int a): java.time.ZonedDateTime", + "insertText": "withSecond" + }, + { + "label": "withYear", + "kind": "method", + "documentation": "withYear(int a): java.time.ZonedDateTime", + "insertText": "withYear" + }, + { + "label": "withZoneSameInstant", + "kind": "method", + "documentation": "withZoneSameInstant(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameInstant" + }, + { + "label": "withZoneSameLocal", + "kind": "method", + "documentation": "withZoneSameLocal(java.time.ZoneId a): java.time.ZonedDateTime", + "insertText": "withZoneSameLocal" + } + ] + }, + { + "label": "ScoreScript.ExplanationHolder", + "kind": "class", + "documentation": "Class: ScoreScript.ExplanationHolder", + "insertText": "ScoreScript.ExplanationHolder", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "set", + "kind": "method", + "documentation": "set(java.lang.String a): void", + "insertText": "set" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "FieldLookup", + "kind": "class", + "documentation": "Class: FieldLookup", + "insertText": "FieldLookup", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "getValue", + "kind": "method", + "documentation": "getValue(): org.elasticsearch.painless.lookup.def", + "insertText": "getValue" + }, + { + "label": "getValues", + "kind": "method", + "documentation": "getValues(): java.util.List", + "insertText": "getValues" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "isEmpty", + "kind": "method", + "documentation": "isEmpty(): boolean", + "insertText": "isEmpty" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript.Factory", + "kind": "class", + "documentation": "Class: org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript.Factory", + "insertText": "org.elasticsearch.xpack.runtimefields.mapper.StringFieldScript.Factory", + "properties": [ + { + "label": "equals", + "kind": "method", + "documentation": "equals(java.lang.Object a): boolean", + "insertText": "equals" + }, + { + "label": "hashCode", + "kind": "method", + "documentation": "hashCode(): int", + "insertText": "hashCode" + }, + { + "label": "toString", + "kind": "method", + "documentation": "toString(): java.lang.String", + "insertText": "toString" + } + ] + }, + { + "label": "short", + "kind": "type", + "documentation": "Primitive: short", + "insertText": "short" + }, + { + "label": "void", + "kind": "type", + "documentation": "Primitive: void", + "insertText": "void" + } + ] +} \ No newline at end of file diff --git a/packages/kbn-monaco/src/painless/completion_adapter.ts b/packages/kbn-monaco/src/painless/completion_adapter.ts new file mode 100644 index 0000000000000..b07018e71b61d --- /dev/null +++ b/packages/kbn-monaco/src/painless/completion_adapter.ts @@ -0,0 +1,110 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { monaco } from '../monaco_imports'; +import { EditorStateService } from './services'; +import { PainlessCompletionResult, PainlessCompletionKind } from './types'; +import { PainlessWorker } from './worker'; + +const getCompletionKind = (kind: PainlessCompletionKind): monaco.languages.CompletionItemKind => { + const monacoItemKind = monaco.languages.CompletionItemKind; + + switch (kind) { + case 'type': + return monacoItemKind.Interface; + case 'class': + return monacoItemKind.Class; + case 'method': + return monacoItemKind.Method; + case 'constructor': + return monacoItemKind.Constructor; + case 'property': + return monacoItemKind.Property; + case 'keyword': + return monacoItemKind.Keyword; + case 'field': + return monacoItemKind.Field; + default: + return monacoItemKind.Text; + } +}; + +export class PainlessCompletionAdapter implements monaco.languages.CompletionItemProvider { + constructor( + private worker: { + (...uris: monaco.Uri[]): Promise; + (arg0: monaco.Uri): Promise; + }, + private editorStateService: EditorStateService + ) {} + + public get triggerCharacters(): string[] { + return ['.', `'`]; + } + + async provideCompletionItems( + model: monaco.editor.IReadOnlyModel, + position: monaco.Position + ): Promise { + // Active line characters + const currentLineChars = model.getValueInRange({ + startLineNumber: position.lineNumber, + startColumn: 0, + endLineNumber: position.lineNumber, + endColumn: position.column, + }); + + const worker = await this.worker(model.uri); + + const { context, fields } = this.editorStateService.getState(); + const autocompleteInfo: PainlessCompletionResult = await worker.provideAutocompleteSuggestions( + currentLineChars, + context, + fields + ); + + const wordInfo = model.getWordUntilPosition(position); + const wordRange = { + startLineNumber: position.lineNumber, + endLineNumber: position.lineNumber, + startColumn: wordInfo.startColumn, + endColumn: wordInfo.endColumn, + }; + + const suggestions = autocompleteInfo.suggestions.map( + ({ label, insertText, documentation, kind, insertTextAsSnippet }) => { + return { + label, + insertText, + documentation, + range: wordRange, + kind: getCompletionKind(kind), + insertTextRules: insertTextAsSnippet + ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet + : undefined, + }; + } + ); + + return { + incomplete: autocompleteInfo.isIncomplete, + suggestions, + }; + } +} diff --git a/packages/kbn-monaco/src/painless/index.ts b/packages/kbn-monaco/src/painless/index.ts index 2ff1f4a19f9bd..3c81f265f9b0d 100644 --- a/packages/kbn-monaco/src/painless/index.ts +++ b/packages/kbn-monaco/src/painless/index.ts @@ -19,5 +19,8 @@ import { ID } from './constants'; import { lexerRules } from './lexer_rules'; +import { getSuggestionProvider } from './language'; -export const PainlessLang = { ID, lexerRules }; +export const PainlessLang = { ID, getSuggestionProvider, lexerRules }; + +export { PainlessContext } from './types'; diff --git a/packages/kbn-monaco/src/painless/language.ts b/packages/kbn-monaco/src/painless/language.ts new file mode 100644 index 0000000000000..f64094dbb482e --- /dev/null +++ b/packages/kbn-monaco/src/painless/language.ts @@ -0,0 +1,45 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { monaco } from '../monaco_imports'; + +import { WorkerProxyService, EditorStateService } from './services'; +import { ID } from './constants'; +import { PainlessContext, Field } from './types'; +import { PainlessWorker } from './worker'; +import { PainlessCompletionAdapter } from './completion_adapter'; + +const workerProxyService = new WorkerProxyService(); +const editorStateService = new EditorStateService(); + +type WorkerAccessor = (...uris: monaco.Uri[]) => Promise; + +const worker: WorkerAccessor = (...uris: monaco.Uri[]): Promise => { + return workerProxyService.getWorker(uris); +}; + +monaco.languages.onLanguage(ID, async () => { + workerProxyService.setup(); +}); + +export const getSuggestionProvider = (context: PainlessContext, fields?: Field[]) => { + editorStateService.setup(context, fields); + + return new PainlessCompletionAdapter(worker, editorStateService); +}; diff --git a/packages/kbn-monaco/src/painless/services/editor_state.ts b/packages/kbn-monaco/src/painless/services/editor_state.ts new file mode 100644 index 0000000000000..b54744152e34d --- /dev/null +++ b/packages/kbn-monaco/src/painless/services/editor_state.ts @@ -0,0 +1,45 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { PainlessContext, Field } from '../types'; + +export interface EditorState { + context: PainlessContext; + fields?: Field[]; +} + +export class EditorStateService { + context: PainlessContext = 'painless_test'; + fields: Field[] = []; + + public getState(): EditorState { + return { + context: this.context, + fields: this.fields, + }; + } + + public setup(context: PainlessContext, fields?: Field[]) { + this.context = context; + + if (fields) { + this.fields = fields; + } + } +} diff --git a/packages/kbn-monaco/src/painless/services/index.ts b/packages/kbn-monaco/src/painless/services/index.ts new file mode 100644 index 0000000000000..e6d118cb92ce7 --- /dev/null +++ b/packages/kbn-monaco/src/painless/services/index.ts @@ -0,0 +1,21 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +export { EditorStateService, EditorState } from './editor_state'; +export { WorkerProxyService } from './worker_proxy'; diff --git a/packages/kbn-monaco/src/painless/services/worker_proxy.ts b/packages/kbn-monaco/src/painless/services/worker_proxy.ts new file mode 100644 index 0000000000000..0db9789a4f423 --- /dev/null +++ b/packages/kbn-monaco/src/painless/services/worker_proxy.ts @@ -0,0 +1,44 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { monaco } from '../../monaco_imports'; +import { PainlessWorker } from '../worker'; +import { ID } from '../constants'; + +export class WorkerProxyService { + private worker: monaco.editor.MonacoWebWorker | undefined; + + public async getWorker(resources: monaco.Uri[]) { + if (!this.worker) { + throw new Error('Worker Proxy Service has not been setup!'); + } + + await this.worker.withSyncedResources(resources); + const proxy = await this.worker.getProxy(); + return proxy; + } + + public setup() { + this.worker = monaco.editor.createWebWorker({ label: ID, moduleId: '' }); + } + + public stop() { + if (this.worker) this.worker.dispose(); + } +} diff --git a/packages/kbn-monaco/src/painless/types.ts b/packages/kbn-monaco/src/painless/types.ts new file mode 100644 index 0000000000000..8afc3dc7ddd88 --- /dev/null +++ b/packages/kbn-monaco/src/painless/types.ts @@ -0,0 +1,57 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +export type PainlessCompletionKind = + | 'type' + | 'class' + | 'method' + | 'constructor' + | 'property' + | 'field' + | 'keyword'; + +export type PainlessContext = + | 'painless_test' + | 'filter' + | 'score' + | 'boolean_script_field_script_field' + | 'date_script_field' + | 'double_script_field_script_field' + | 'ip_script_field_script_field' + | 'long_script_field_script_field' + | 'processor_conditional' + | 'string_script_field_script_field'; + +export interface PainlessCompletionItem { + label: string; + kind: PainlessCompletionKind; + documentation: string; + insertText: string; + insertTextAsSnippet?: boolean; +} + +export interface PainlessCompletionResult { + isIncomplete: boolean; + suggestions: PainlessCompletionItem[]; +} + +export interface Field { + name: string; + type: string; +} diff --git a/packages/kbn-monaco/src/painless/worker/index.ts b/packages/kbn-monaco/src/painless/worker/index.ts new file mode 100644 index 0000000000000..2f55271ab9958 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/index.ts @@ -0,0 +1,20 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +export { PainlessWorker } from './painless_worker'; diff --git a/packages/kbn-monaco/src/painless/worker/lib/autocomplete.test.ts b/packages/kbn-monaco/src/painless/worker/lib/autocomplete.test.ts new file mode 100644 index 0000000000000..8cc5d21d9d7e0 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/lib/autocomplete.test.ts @@ -0,0 +1,228 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { PainlessCompletionItem } from '../../types'; +import { lexerRules } from '../../lexer_rules'; + +import { + getStaticSuggestions, + getFieldSuggestions, + getClassMemberSuggestions, + getPrimitives, + getConstructorSuggestions, + Suggestion, +} from './autocomplete'; + +const keywords: PainlessCompletionItem[] = lexerRules.keywords.map((keyword) => { + return { + label: keyword, + kind: 'keyword', + documentation: 'Keyword: char', + insertText: keyword, + }; +}); + +const testSuggestions: Suggestion[] = [ + { + properties: undefined, + constructorDefinition: undefined, + documentation: 'Primitive: boolean', + insertText: 'boolean', + kind: 'type', + label: 'boolean', + }, + { + properties: undefined, + constructorDefinition: undefined, + documentation: 'Primitive: int', + insertText: 'int', + kind: 'type', + label: 'int', + }, + { + properties: [ + { + documentation: 'PI: double', + insertText: 'PI', + kind: 'property', + label: 'PI', + }, + { + documentation: 'pow(double a, double b): double', + insertText: 'pow', + kind: 'method', + label: 'pow', + }, + ], + constructorDefinition: undefined, + documentation: 'Class: Math', + insertText: 'Math', + kind: 'class', + label: 'Math', + }, + { + constructorDefinition: { + documentation: 'Constructor: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'constructor', + label: 'ArithmeticException', + }, + documentation: 'Class: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'class', + label: 'ArithmeticException', + properties: [ + { + documentation: 'equals(java.lang.Object a): boolean', + insertText: 'equals', + kind: 'method', + label: 'equals', + }, + ], + }, +]; + +describe('Autocomplete lib', () => { + describe('Static suggestions', () => { + test('returns static suggestions', () => { + expect(getStaticSuggestions(testSuggestions, false)).toEqual({ + isIncomplete: false, + suggestions: [ + { + documentation: 'Primitive: boolean', + insertText: 'boolean', + kind: 'type', + label: 'boolean', + }, + { + documentation: 'Primitive: int', + insertText: 'int', + kind: 'type', + label: 'int', + }, + { + documentation: 'Class: Math', + insertText: 'Math', + kind: 'class', + label: 'Math', + }, + { + documentation: 'Class: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'class', + label: 'ArithmeticException', + }, + ...keywords, + ], + }); + }); + + test('returns doc keyword when fields exist', () => { + const autocompletion = getStaticSuggestions(testSuggestions, true); + const docSuggestion = autocompletion.suggestions.find( + (suggestion) => suggestion.label === 'doc' + ); + expect(Boolean(docSuggestion)).toBe(true); + }); + }); + + describe('getPrimitives()', () => { + test('returns primitive values', () => { + expect(getPrimitives(testSuggestions)).toEqual(['boolean', 'int']); + }); + }); + + describe('getClassMemberSuggestions()', () => { + test('returns class member suggestions', () => { + expect(getClassMemberSuggestions(testSuggestions, 'Math')).toEqual({ + isIncomplete: false, + suggestions: [ + { + documentation: 'PI: double', + insertText: 'PI', + kind: 'property', + label: 'PI', + }, + { + documentation: 'pow(double a, double b): double', + insertText: 'pow', + kind: 'method', + label: 'pow', + }, + ], + }); + }); + + test('returns an empty suggestions array if class does not exist', () => { + expect(getClassMemberSuggestions(testSuggestions, 'foobar')).toEqual({ + isIncomplete: false, + suggestions: [], + }); + }); + }); + + describe('getFieldSuggestions()', () => { + test('returns field suggestions', () => { + const fields = [ + { + name: 'field1', + type: 'float', + }, + { + name: 'field2', + type: 'boolean', + }, + ]; + + expect(getFieldSuggestions(fields)).toEqual({ + isIncomplete: false, + suggestions: [ + { + documentation: `Retrieve the value for field 'field1'`, + insertText: `field1'`, + kind: 'field', + label: 'field1', + }, + { + documentation: `Retrieve the value for field 'field2'`, + insertText: `field2'`, + kind: 'field', + label: 'field2', + }, + ], + }); + }); + }); + + describe('getConstructorSuggestions()', () => { + test('returns constructor suggestions', () => { + expect(getConstructorSuggestions(testSuggestions)).toEqual({ + isIncomplete: false, + suggestions: [ + { + documentation: 'Constructor: ArithmeticException', + insertText: 'ArithmeticException', + kind: 'constructor', + label: 'ArithmeticException', + }, + ], + }); + }); + }); +}); diff --git a/packages/kbn-monaco/src/painless/worker/lib/autocomplete.ts b/packages/kbn-monaco/src/painless/worker/lib/autocomplete.ts new file mode 100644 index 0000000000000..5536da828be42 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/lib/autocomplete.ts @@ -0,0 +1,194 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { i18n } from '@kbn/i18n'; + +import { + PainlessCompletionResult, + PainlessCompletionItem, + PainlessContext, + Field, +} from '../../types'; + +import { + painlessTestContext, + scoreContext, + filterContext, + booleanScriptFieldScriptFieldContext, + dateScriptFieldContext, + doubleScriptFieldScriptFieldContext, + ipScriptFieldScriptFieldContext, + longScriptFieldScriptFieldContext, + processorConditionalContext, + stringScriptFieldScriptFieldContext, +} from '../../autocomplete_definitions'; + +import { lexerRules } from '../../lexer_rules'; + +import { + isDeclaringField, + isConstructorInstance, + isAccessingProperty, + showStaticSuggestions, +} from './autocomplete_utils'; + +export interface Suggestion extends PainlessCompletionItem { + properties?: PainlessCompletionItem[]; + constructorDefinition?: PainlessCompletionItem; +} + +const keywords: PainlessCompletionItem[] = lexerRules.keywords.map((keyword) => { + return { + label: keyword, + kind: 'keyword', + documentation: 'Keyword: char', + insertText: keyword, + }; +}); + +const mapContextToData: { [key: string]: { suggestions: any[] } } = { + painless_test: painlessTestContext, + score: scoreContext, + filter: filterContext, + boolean_script_field_script_field: booleanScriptFieldScriptFieldContext, + date_script_field: dateScriptFieldContext, + double_script_field_script_field: doubleScriptFieldScriptFieldContext, + ip_script_field_script_field: ipScriptFieldScriptFieldContext, + long_script_field_script_field: longScriptFieldScriptFieldContext, + processor_conditional: processorConditionalContext, + string_script_field_script_field: stringScriptFieldScriptFieldContext, +}; + +export const getStaticSuggestions = ( + suggestions: Suggestion[], + hasFields: boolean +): PainlessCompletionResult => { + const classSuggestions: PainlessCompletionItem[] = suggestions.map((suggestion) => { + const { properties, constructorDefinition, ...rootSuggestion } = suggestion; + return rootSuggestion; + }); + + const keywordSuggestions: PainlessCompletionItem[] = hasFields + ? [ + ...keywords, + { + label: 'doc', + kind: 'keyword', + documentation: i18n.translate( + 'monaco.painlessLanguage.autocomplete.docKeywordDescription', + { + defaultMessage: `Access a field value from a script using the doc['field_name'] syntax`, + } + ), + insertText: "doc[${1:'my_field'}]", + insertTextAsSnippet: true, + }, + ] + : keywords; + + return { + isIncomplete: false, + suggestions: [...classSuggestions, ...keywordSuggestions], + }; +}; + +export const getPrimitives = (suggestions: Suggestion[]): string[] => { + return suggestions.filter((suggestion) => suggestion.kind === 'type').map((type) => type.label); +}; + +export const getClassMemberSuggestions = ( + suggestions: Suggestion[], + className: string +): PainlessCompletionResult => { + const painlessClass = suggestions.find((suggestion) => suggestion.label === className); + + return { + isIncomplete: false, + suggestions: painlessClass?.properties || [], + }; +}; + +export const getFieldSuggestions = (fields: Field[]): PainlessCompletionResult => { + const suggestions: PainlessCompletionItem[] = fields.map(({ name }) => { + return { + label: name, + kind: 'field', + documentation: i18n.translate('monaco.painlessLanguage.autocomplete.fieldValueDescription', { + defaultMessage: `Retrieve the value for field '{fieldName}'`, + values: { + fieldName: name, + }, + }), + // A trailing quotation mark is added to format the field for the user + insertText: `${name}'`, + }; + }); + + return { + isIncomplete: false, + suggestions, + }; +}; + +export const getConstructorSuggestions = (suggestions: Suggestion[]): PainlessCompletionResult => { + let constructorSuggestions: PainlessCompletionItem[] = []; + + const suggestionsWithConstructors = suggestions.filter( + (suggestion) => suggestion.constructorDefinition + ); + + if (suggestionsWithConstructors) { + constructorSuggestions = suggestionsWithConstructors.map( + (filteredSuggestion) => filteredSuggestion.constructorDefinition! + ); + } + + return { + isIncomplete: false, + suggestions: constructorSuggestions, + }; +}; + +export const getAutocompleteSuggestions = ( + painlessContext: PainlessContext, + words: string[], + fields?: Field[] +): PainlessCompletionResult => { + const suggestions = mapContextToData[painlessContext].suggestions; + // What the user is currently typing + const activeTyping = words[words.length - 1]; + const primitives = getPrimitives(suggestions); + + let autocompleteSuggestions: PainlessCompletionResult = { + isIncomplete: false, + suggestions: [], + }; + + if (isConstructorInstance(words)) { + autocompleteSuggestions = getConstructorSuggestions(suggestions); + } else if (fields && isDeclaringField(activeTyping)) { + autocompleteSuggestions = getFieldSuggestions(fields); + } else if (isAccessingProperty(activeTyping)) { + const className = activeTyping.substring(0, activeTyping.length - 1).split('.')[0]; + autocompleteSuggestions = getClassMemberSuggestions(suggestions, className); + } else if (showStaticSuggestions(activeTyping, words, primitives)) { + autocompleteSuggestions = getStaticSuggestions(suggestions, Boolean(fields?.length)); + } + return autocompleteSuggestions; +}; diff --git a/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.test.ts b/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.test.ts new file mode 100644 index 0000000000000..d9420719f6923 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.test.ts @@ -0,0 +1,77 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { + isDeclaringField, + isConstructorInstance, + hasDeclaredType, + isAccessingProperty, + showStaticSuggestions, +} from './autocomplete_utils'; + +const primitives = ['boolean', 'int', 'char', 'float', 'double']; + +describe('Utils', () => { + describe('isDeclaringField()', () => { + test('returns true or false depending if a string contains the expected document syntax', () => { + expect(isDeclaringField(`doc['`)).toEqual(true); + expect(isDeclaringField(`i { + test('returns true or false depending if an array contains the "new" keyword at a specific index', () => { + expect(isConstructorInstance(['int', 'myConstructor', '=', 'new', 'A'])).toEqual(true); + expect(isConstructorInstance(['new', 'A'])).toEqual(true); + expect(isConstructorInstance(['int', 'new', '=', 'a'])).toEqual(false); + }); + }); + + describe('hasDeclaredType()', () => { + test('returns true or false depending if an array contains a primitive type at a specific index', () => { + expect(hasDeclaredType(['boolean', 'a'], primitives)).toEqual(true); + expect(hasDeclaredType(['foobar', 'a'], primitives)).toEqual(false); + }); + }); + + describe('isAccessingProperty()', () => { + test('returns true or false depending if a string contains a "."', () => { + expect(isAccessingProperty('Math.')).toEqual(true); + expect(isAccessingProperty('Math.E')).toEqual(true); + expect(isAccessingProperty('Math.E.foobar')).toEqual(false); + expect(isAccessingProperty('foobar')).toEqual(false); + expect(isAccessingProperty('Math.floor(')).toEqual(false); + }); + }); + + describe('showStaticSuggestions()', () => { + test('returns true or false depending if a type is declared or the string contains a "."', () => { + expect(showStaticSuggestions('a', ['a'], primitives)).toEqual(true); + expect(showStaticSuggestions('foobar a', ['foobar', 'a'], primitives)).toEqual(true); + expect(showStaticSuggestions(`${primitives[0]} a`, [primitives[0], 'a'], primitives)).toEqual( + false + ); + expect(showStaticSuggestions('field1.field2.a', ['field1.field2.a'], primitives)).toEqual( + false + ); + }); + }); +}); diff --git a/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.ts b/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.ts new file mode 100644 index 0000000000000..7c53d2f8167bd --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/lib/autocomplete_utils.ts @@ -0,0 +1,76 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +/** + * If the active typing contains dot notation, we assume we need to access the object's properties + * Currently only supporting one-level deep nesting + */ +export const isAccessingProperty = (activeTyping: string): boolean => { + const activeTypingParts = activeTyping.split('.'); + + if (activeTypingParts.length !== 2) { + return false; + } + + const maybeProperty = activeTypingParts[1]; + + return maybeProperty.includes('(') === false; +}; + +/** + * If the preceding word is a primitive type, e.g., "boolean", + * we assume the user is declaring a variable and will skip autocomplete + */ +export const hasDeclaredType = (activeLineWords: string[], primitives: string[]): boolean => { + return activeLineWords.length === 2 && primitives.includes(activeLineWords[0]); +}; + +/** + * Check if the preceding word contains the "new" keyword + */ +export const isConstructorInstance = (activeLineWords: string[]): boolean => { + return activeLineWords[activeLineWords.length - 2] === 'new'; +}; + +/** + * Check if the user appears to be accessing a document field + */ +export const isDeclaringField = (activeTyping: string): boolean => { + const triggerString = `doc['`; + const startIndex = activeTyping.indexOf(triggerString); + const endIndex = startIndex + (triggerString.length - 1); + + return startIndex !== -1 && activeTyping.length - 1 === endIndex; +}; + +/** + * Static suggestions serve as a catch-all most of the time + * However, there are a few situations where we do not want to show them and instead default to the built-in monaco (abc) autocomplete + * 1. If the preceding word is a type, e.g., "boolean", we assume the user is declaring a variable name + * 2. If the string contains a "dot" character, we assume the user is attempting to access a property that we do not have information for + */ +export const showStaticSuggestions = ( + activeTyping: string, + activeLineWords: string[], + primitives: string[] +): boolean => { + const activeTypingParts = activeTyping.split('.'); + + return hasDeclaredType(activeLineWords, primitives) === false && activeTypingParts.length === 1; +}; diff --git a/packages/kbn-monaco/src/painless/worker/lib/index.ts b/packages/kbn-monaco/src/painless/worker/lib/index.ts new file mode 100644 index 0000000000000..b2d4fc1f4faf4 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/lib/index.ts @@ -0,0 +1,20 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +export { getAutocompleteSuggestions } from './autocomplete'; diff --git a/packages/kbn-monaco/src/painless/worker/painless.worker.ts b/packages/kbn-monaco/src/painless/worker/painless.worker.ts new file mode 100644 index 0000000000000..de40fda360d76 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/painless.worker.ts @@ -0,0 +1,32 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +// This module is intended to be run inside of a webworker +/* eslint-disable @kbn/eslint/module_migration */ + +import 'regenerator-runtime/runtime'; +// @ts-ignore +import * as worker from 'monaco-editor/esm/vs/editor/editor.worker'; +import { PainlessWorker } from './painless_worker'; + +self.onmessage = () => { + worker.initialize((ctx: any, createData: any) => { + return new PainlessWorker(); + }); +}; diff --git a/packages/kbn-monaco/src/painless/worker/painless_worker.ts b/packages/kbn-monaco/src/painless/worker/painless_worker.ts new file mode 100644 index 0000000000000..357d81354ac43 --- /dev/null +++ b/packages/kbn-monaco/src/painless/worker/painless_worker.ts @@ -0,0 +1,41 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you 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. + */ + +import { PainlessCompletionResult, PainlessContext, Field } from '../types'; + +import { getAutocompleteSuggestions } from './lib'; + +export class PainlessWorker { + public provideAutocompleteSuggestions( + currentLineChars: string, + context: PainlessContext, + fields?: Field[] + ): PainlessCompletionResult { + // Array of the active line words, e.g., [boolean, isTrue, =, true] + const words = currentLineChars.replace('\t', '').split(' '); + + const autocompleteSuggestions: PainlessCompletionResult = getAutocompleteSuggestions( + context, + words, + fields + ); + + return autocompleteSuggestions; + } +} diff --git a/packages/kbn-monaco/src/register_globals.ts b/packages/kbn-monaco/src/register_globals.ts index b9e94803b7542..630467dd81711 100644 --- a/packages/kbn-monaco/src/register_globals.ts +++ b/packages/kbn-monaco/src/register_globals.ts @@ -25,6 +25,8 @@ import { monaco } from './monaco_imports'; import xJsonWorkerSrc from '!!raw-loader!../target/public/xjson.editor.worker.js'; // @ts-ignore import defaultWorkerSrc from '!!raw-loader!../target/public/default.editor.worker.js'; +// @ts-ignore +import painlessWorkerSrc from '!!raw-loader!../target/public/painless.editor.worker.js'; /** * Register languages and lexer rules @@ -42,6 +44,7 @@ monaco.languages.setMonarchTokensProvider(EsqlLang.ID, EsqlLang.lexerRules); */ const mapLanguageIdToWorker: { [key: string]: any } = { [XJsonLang.ID]: xJsonWorkerSrc, + [PainlessLang.ID]: painlessWorkerSrc, }; // @ts-ignore diff --git a/packages/kbn-monaco/webpack.config.js b/packages/kbn-monaco/webpack.config.js index 53f440689a233..1a024069e8b31 100644 --- a/packages/kbn-monaco/webpack.config.js +++ b/packages/kbn-monaco/webpack.config.js @@ -55,4 +55,8 @@ const createLangWorkerConfig = (lang) => { }; }; -module.exports = [createLangWorkerConfig('xjson'), createLangWorkerConfig('default')]; +module.exports = [ + createLangWorkerConfig('xjson'), + createLangWorkerConfig('painless'), + createLangWorkerConfig('default'), +]; diff --git a/src/plugins/data/common/index_patterns/index_patterns/index_patterns.ts b/src/plugins/data/common/index_patterns/index_patterns/index_patterns.ts index e09246ae8cd3e..4a266b3cad649 100644 --- a/src/plugins/data/common/index_patterns/index_patterns/index_patterns.ts +++ b/src/plugins/data/common/index_patterns/index_patterns/index_patterns.ts @@ -135,6 +135,20 @@ export class IndexPatternsService { return this.savedObjectsCache.map((obj) => obj?.attributes?.title); }; + find = async (search: string, size: number = 10): Promise => { + const savedObjects = await this.savedObjectsClient.find({ + type: 'index-pattern', + fields: ['title'], + search, + searchFields: ['title'], + perPage: size, + }); + const getIndexPatternPromises = savedObjects.map(async (savedObject) => { + return await this.get(savedObject.id); + }); + return await Promise.all(getIndexPatternPromises); + }; + /** * Get list of index pattern ids with titles * @param refresh Force refresh of index pattern list diff --git a/src/plugins/data/public/plugin.ts b/src/plugins/data/public/plugin.ts index dded52310a99c..8d40447a48ff0 100644 --- a/src/plugins/data/public/plugin.ts +++ b/src/plugins/data/public/plugin.ts @@ -229,7 +229,7 @@ export class DataPublicPlugin return { ...dataServices, ui: { - IndexPatternSelect: createIndexPatternSelect(core.savedObjects.client), + IndexPatternSelect: createIndexPatternSelect(indexPatterns), SearchBar, }, }; diff --git a/src/plugins/data/public/public.api.md b/src/plugins/data/public/public.api.md index a6daaf834a424..8ceb91269adbe 100644 --- a/src/plugins/data/public/public.api.md +++ b/src/plugins/data/public/public.api.md @@ -1396,6 +1396,8 @@ export class IndexPatternsService { // (undocumented) ensureDefaultIndexPattern: EnsureDefaultIndexPattern; fieldArrayToMap: (fields: FieldSpec[], fieldAttrs?: FieldAttrs | undefined) => Record; + // (undocumented) + find: (search: string, size?: number) => Promise; get: (id: string) => Promise; // Warning: (ae-forgotten-export) The symbol "IndexPatternSavedObjectAttrs" needs to be exported by the entry point index.d.ts // diff --git a/src/plugins/data/public/ui/index_pattern_select/create_index_pattern_select.tsx b/src/plugins/data/public/ui/index_pattern_select/create_index_pattern_select.tsx index a48c2dabf1506..11cf8edee5aae 100644 --- a/src/plugins/data/public/ui/index_pattern_select/create_index_pattern_select.tsx +++ b/src/plugins/data/public/ui/index_pattern_select/create_index_pattern_select.tsx @@ -20,12 +20,12 @@ import _ from 'lodash'; import React from 'react'; -import { SavedObjectsClientContract } from 'src/core/public'; +import { IndexPatternsContract } from 'src/plugins/data/public'; import { IndexPatternSelect, IndexPatternSelectProps } from './'; // Takes in stateful runtime dependencies and pre-wires them to the component -export function createIndexPatternSelect(savedObjectsClient: SavedObjectsClientContract) { +export function createIndexPatternSelect(indexPatternService: IndexPatternsContract) { return (props: IndexPatternSelectProps) => ( - + ); } diff --git a/src/plugins/data/public/ui/index_pattern_select/index_pattern_select.tsx b/src/plugins/data/public/ui/index_pattern_select/index_pattern_select.tsx index 1e0e8934778ad..2388f3d7a504b 100644 --- a/src/plugins/data/public/ui/index_pattern_select/index_pattern_select.tsx +++ b/src/plugins/data/public/ui/index_pattern_select/index_pattern_select.tsx @@ -23,8 +23,7 @@ import React, { Component } from 'react'; import { Required } from '@kbn/utility-types'; import { EuiComboBox, EuiComboBoxProps } from '@elastic/eui'; -import { SavedObjectsClientContract, SimpleSavedObject } from 'src/core/public'; -import { getTitle } from '../../../common/index_patterns/lib'; +import { IndexPatternsContract } from 'src/plugins/data/public'; export type IndexPatternSelectProps = Required< Omit< @@ -40,7 +39,7 @@ export type IndexPatternSelectProps = Required< }; export type IndexPatternSelectInternalProps = IndexPatternSelectProps & { - savedObjectsClient: SavedObjectsClientContract; + indexPatternService: IndexPatternsContract; }; interface IndexPatternSelectState { @@ -50,21 +49,6 @@ interface IndexPatternSelectState { searchValue: string | undefined; } -const getIndexPatterns = async ( - client: SavedObjectsClientContract, - search: string, - fields: string[] -) => { - const resp = await client.find({ - type: 'index-pattern', - fields, - search: `${search}*`, - searchFields: ['title'], - perPage: 100, - }); - return resp.savedObjects; -}; - // Needed for React.lazy // eslint-disable-next-line import/no-default-export export default class IndexPatternSelect extends Component { @@ -109,7 +93,8 @@ export default class IndexPatternSelect extends Component { - const { fieldTypes, onNoIndexPatterns, savedObjectsClient } = this.props; - - const savedObjectFields = ['title']; - if (fieldTypes) { - savedObjectFields.push('fields'); - } - let savedObjects = await getIndexPatterns(savedObjectsClient, searchValue, savedObjectFields); - - if (fieldTypes) { - savedObjects = savedObjects.filter((savedObject: SimpleSavedObject) => { - try { - const indexPatternFields = JSON.parse(savedObject.attributes.fields as any); - return indexPatternFields.some((field: any) => { - return fieldTypes?.includes(field.type); - }); - } catch (err) { - // Unable to parse fields JSON, invalid index pattern - return false; - } - }); - } + const { fieldTypes, onNoIndexPatterns, indexPatternService } = this.props; + const indexPatterns = await indexPatternService.find(`${searchValue}*`, 100); - if (!this.isMounted) { + // We need this check to handle the case where search results come back in a different + // order than they were sent out. Only load results for the most recent search. + if (searchValue !== this.state.searchValue || !this.isMounted) { return; } - // We need this check to handle the case where search results come back in a different - // order than they were sent out. Only load results for the most recent search. - if (searchValue === this.state.searchValue) { - const options = savedObjects.map((indexPatternSavedObject: SimpleSavedObject) => { + const options = indexPatterns + .filter((indexPattern) => { + return fieldTypes + ? indexPattern.fields.some((field) => { + return fieldTypes.includes(field.type); + }) + : true; + }) + .map((indexPattern) => { return { - label: indexPatternSavedObject.attributes.title, - value: indexPatternSavedObject.id, + label: indexPattern.title, + value: indexPattern.id, }; }); - this.setState({ - isLoading: false, - options, - }); + this.setState({ + isLoading: false, + options, + }); - if (onNoIndexPatterns && searchValue === '' && options.length === 0) { - onNoIndexPatterns(); - } + if (onNoIndexPatterns && searchValue === '' && options.length === 0) { + onNoIndexPatterns(); } }, 300); @@ -195,7 +167,7 @@ export default class IndexPatternSelect extends Component column.id === outputColumnId)) { + if ( + !options.allowColumnOverwrite && + input.columns.some((column) => column.id === outputColumnId) + ) { throw new Error( i18n.translate('expressions.functions.seriesCalculations.columnConflictMessage', { defaultMessage: diff --git a/src/plugins/kibana_usage_collection/server/collectors/application_usage/telemetry_application_usage_collector.test.ts b/src/plugins/kibana_usage_collection/server/collectors/application_usage/telemetry_application_usage_collector.test.ts index 6cb104416ef58..47dc26e0ab3d8 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/application_usage/telemetry_application_usage_collector.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/application_usage/telemetry_application_usage_collector.test.ts @@ -40,7 +40,7 @@ describe('telemetry_application_usage', () => { const logger = loggingSystemMock.createLogger(); - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeUsageCollector.mockImplementation((config) => { diff --git a/src/plugins/kibana_usage_collection/server/collectors/core/core_usage_collector.ts b/src/plugins/kibana_usage_collection/server/collectors/core/core_usage_collector.ts index 297baf016e9e6..3fd011b0bded2 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/core/core_usage_collector.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/core/core_usage_collector.ts @@ -24,7 +24,7 @@ export function getCoreUsageCollector( usageCollection: UsageCollectionSetup, getCoreUsageDataService: () => CoreUsageDataStart ) { - return usageCollection.makeUsageCollector({ + return usageCollection.makeUsageCollector({ type: 'core', isReady: () => typeof getCoreUsageDataService() !== 'undefined', schema: { diff --git a/src/plugins/kibana_usage_collection/server/collectors/core/index.test.ts b/src/plugins/kibana_usage_collection/server/collectors/core/index.test.ts index e31437a744e29..335d73fb60847 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/core/index.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/core/index.test.ts @@ -29,7 +29,7 @@ import { CoreUsageData } from 'src/core/server/'; const logger = loggingSystemMock.createLogger(); describe('telemetry_core', () => { - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeUsageCollector.mockImplementation((config) => { diff --git a/src/plugins/kibana_usage_collection/server/collectors/kibana/index.test.ts b/src/plugins/kibana_usage_collection/server/collectors/kibana/index.test.ts index 16a60eca60f47..83cac1d456a3a 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/kibana/index.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/kibana/index.test.ts @@ -31,7 +31,7 @@ import { registerKibanaUsageCollector } from './'; const logger = loggingSystemMock.createLogger(); describe('telemetry_kibana', () => { - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeUsageCollector.mockImplementation((config) => { @@ -66,23 +66,4 @@ describe('telemetry_kibana', () => { timelion_sheet: { total: 0 }, }); }); - - test('formatForBulkUpload', async () => { - const resultFromFetch = { - index: '.kibana-tests', - dashboard: { total: 0 }, - visualization: { total: 0 }, - search: { total: 0 }, - index_pattern: { total: 0 }, - graph_workspace: { total: 0 }, - timelion_sheet: { total: 0 }, - }; - - expect(collector.formatForBulkUpload!(resultFromFetch)).toStrictEqual({ - type: 'kibana_stats', - payload: { - usage: resultFromFetch, - }, - }); - }); }); diff --git a/src/plugins/kibana_usage_collection/server/collectors/kibana/kibana_usage_collector.ts b/src/plugins/kibana_usage_collection/server/collectors/kibana/kibana_usage_collector.ts index d292b2d5ace0e..6c2e0a2c926ad 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/kibana/kibana_usage_collector.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/kibana/kibana_usage_collector.ts @@ -21,7 +21,6 @@ import { Observable } from 'rxjs'; import { take } from 'rxjs/operators'; import { SharedGlobalConfig } from 'kibana/server'; import { UsageCollectionSetup } from 'src/plugins/usage_collection/server'; -import { KIBANA_STATS_TYPE } from '../../../common/constants'; import { getSavedObjectsCounts, KibanaSavedObjectCounts } from './get_saved_object_counts'; interface KibanaUsage extends KibanaSavedObjectCounts { @@ -32,7 +31,7 @@ export function getKibanaUsageCollector( usageCollection: UsageCollectionSetup, legacyConfig$: Observable ) { - return usageCollection.makeUsageCollector({ + return usageCollection.makeUsageCollector({ type: 'kibana', isReady: () => true, schema: { @@ -53,20 +52,6 @@ export function getKibanaUsageCollector( ...(await getSavedObjectsCounts(callCluster, index)), }; }, - - /* - * Format the response data into a model for internal upload - * 1. Make this data part of the "kibana_stats" type - * 2. Organize the payload in the usage namespace of the data payload (usage.index, etc) - */ - formatForBulkUpload: (result) => { - return { - type: KIBANA_STATS_TYPE, - payload: { - usage: result, - }, - }; - }, }); } diff --git a/src/plugins/kibana_usage_collection/server/collectors/management/index.test.ts b/src/plugins/kibana_usage_collection/server/collectors/management/index.test.ts index 0aafee01cf49d..bd63c5b40735a 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/management/index.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/management/index.test.ts @@ -29,7 +29,7 @@ import { registerManagementUsageCollector } from './'; const logger = loggingSystemMock.createLogger(); describe('telemetry_application_usage_collector', () => { - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeUsageCollector.mockImplementation((config) => { diff --git a/src/plugins/kibana_usage_collection/server/collectors/ops_stats/index.test.ts b/src/plugins/kibana_usage_collection/server/collectors/ops_stats/index.test.ts index 8db7010e64026..1aa60e2c8e961 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/ops_stats/index.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/ops_stats/index.test.ts @@ -31,7 +31,7 @@ import { loggingSystemMock } from '../../../../../core/server/mocks'; const logger = loggingSystemMock.createLogger(); describe('telemetry_ops_stats', () => { - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeStatsCollector.mockImplementation((config) => { diff --git a/src/plugins/kibana_usage_collection/server/collectors/ui_metric/index.test.ts b/src/plugins/kibana_usage_collection/server/collectors/ui_metric/index.test.ts index 90e3b7110e1dc..d852e505027fa 100644 --- a/src/plugins/kibana_usage_collection/server/collectors/ui_metric/index.test.ts +++ b/src/plugins/kibana_usage_collection/server/collectors/ui_metric/index.test.ts @@ -29,7 +29,7 @@ import { registerUiMetricUsageCollector } from './'; const logger = loggingSystemMock.createLogger(); describe('telemetry_ui_metric', () => { - let collector: Collector; + let collector: Collector; const usageCollectionMock = createUsageCollectionSetupMock(); usageCollectionMock.makeUsageCollector.mockImplementation((config) => { diff --git a/src/plugins/usage_collection/server/collector/collector.test.ts b/src/plugins/usage_collection/server/collector/collector.test.ts index 875414fbeec48..fe52b9b2ca03e 100644 --- a/src/plugins/usage_collection/server/collector/collector.test.ts +++ b/src/plugins/usage_collection/server/collector/collector.test.ts @@ -19,7 +19,6 @@ import { loggingSystemMock } from '../../../../core/server/mocks'; import { Collector } from './collector'; -import { UsageCollector } from './usage_collector'; const logger = loggingSystemMock.createLogger(); @@ -88,49 +87,6 @@ describe('collector', () => { }); }); - describe('formatForBulkUpload', () => { - it('should use the default formatter', () => { - const fetchOutput = { testPass: 100 }; - const collector = new Collector(logger, { - type: 'my_test_collector', - isReady: () => false, - fetch: () => fetchOutput, - }); - expect(collector.formatForBulkUpload(fetchOutput)).toStrictEqual({ - type: 'my_test_collector', - payload: fetchOutput, - }); - }); - - it('should use a custom formatter', () => { - const fetchOutput = { testPass: 100 }; - const collector = new Collector(logger, { - type: 'my_test_collector', - isReady: () => false, - fetch: () => fetchOutput, - formatForBulkUpload: (a) => ({ type: 'other_value', payload: { nested: a } }), - }); - expect(collector.formatForBulkUpload(fetchOutput)).toStrictEqual({ - type: 'other_value', - payload: { nested: fetchOutput }, - }); - }); - - it("should use UsageCollector's default formatter", () => { - const fetchOutput = { testPass: 100 }; - const collector = new UsageCollector(logger, { - type: 'my_test_collector', - isReady: () => false, - fetch: () => fetchOutput, - schema: { testPass: { type: 'long' } }, - }); - expect(collector.formatForBulkUpload(fetchOutput)).toStrictEqual({ - type: 'kibana_stats', - payload: { usage: { my_test_collector: fetchOutput } }, - }); - }); - }); - describe('schema TS validations', () => { // These tests below are used to ensure types inference is working as expected. // We don't intend to test any logic as such, just the relation between the types in `fetch` and `schema`. diff --git a/src/plugins/usage_collection/server/collector/collector.ts b/src/plugins/usage_collection/server/collector/collector.ts index 797fdaa06a620..8e86bc3d1cd26 100644 --- a/src/plugins/usage_collection/server/collector/collector.ts +++ b/src/plugins/usage_collection/server/collector/collector.ts @@ -26,8 +26,6 @@ import { KibanaRequest, } from 'src/core/server'; -export type CollectorFormatForBulkUpload = (result: T) => { type: string; payload: U }; - export type AllowedSchemaNumberTypes = 'long' | 'integer' | 'short' | 'byte' | 'double' | 'float'; export type AllowedSchemaTypes = AllowedSchemaNumberTypes | 'keyword' | 'text' | 'boolean' | 'date'; @@ -87,7 +85,7 @@ export type CollectorFetchMethod< TReturn, ExtraOptions extends object = {} > = ( - this: Collector & ExtraOptions, // Specify the context of `this` for this.log and others to become available + this: Collector & ExtraOptions, // Specify the context of `this` for this.log and others to become available context: CollectorFetchContext ) => Promise | TReturn; @@ -108,7 +106,6 @@ export type CollectorOptionsFetchExtendedContext< export type CollectorOptions< TFetchReturn = unknown, - UFormatBulkUploadPayload = TFetchReturn, // TODO: Once we remove bulk_uploader's dependency on usageCollection, we'll be able to remove this type WithKibanaRequest extends boolean = boolean, ExtraOptions extends object = {} > = { @@ -130,13 +127,6 @@ export type CollectorOptions< * @param collectorFetchContext {@link CollectorFetchContext} */ fetch: CollectorFetchMethod; - /** - * A hook for allowing the fetched data payload to be organized into a typed - * data model for internal bulk upload. See defaultFormatterForBulkUpload for - * a generic example. - * @deprecated Used only by the Legacy Monitoring collection (to be removed in 8.0) - */ - formatForBulkUpload?: CollectorFormatForBulkUpload; } & ExtraOptions & (WithKibanaRequest extends true // If enforced to true via Types, the config must be enforced ? { @@ -146,28 +136,16 @@ export type CollectorOptions< extendFetchContext?: CollectorOptionsFetchExtendedContext; }); -export class Collector< - TFetchReturn, - UFormatBulkUploadPayload = TFetchReturn, - ExtraOptions extends object = {} -> { +export class Collector { public readonly extendFetchContext: CollectorOptionsFetchExtendedContext; - public readonly type: CollectorOptions['type']; - public readonly init?: CollectorOptions['init']; + public readonly type: CollectorOptions['type']; + public readonly init?: CollectorOptions['init']; public readonly fetch: CollectorFetchMethod; - public readonly isReady: CollectorOptions['isReady']; - private readonly _formatForBulkUpload?: CollectorFormatForBulkUpload< - TFetchReturn, - UFormatBulkUploadPayload - >; - /* - * @param {Object} logger - logger object - * @param {String} options.type - property name as the key for the data - * @param {Function} options.init (optional) - initialization function - * @param {Function} options.fetch - function to query data - * @param {Function} options.formatForBulkUpload - optional - * @param {Function} options.isReady - method that returns a boolean or Promise of a boolean to indicate the collector is ready to report data - * @param {Function} options.rest - optional other properties + public readonly isReady: CollectorOptions['isReady']; + /** + * @private Constructor of a Collector. It should be called via the CollectorSet factory methods: `makeStatsCollector` and `makeUsageCollector` + * @param log {@link Logger} + * @param collectorDefinition {@link CollectorOptions} */ constructor( public readonly log: Logger, @@ -175,11 +153,10 @@ export class Collector< type, init, fetch, - formatForBulkUpload, isReady, extendFetchContext = {}, ...options - }: CollectorOptions + }: CollectorOptions ) { if (type === undefined) { throw new Error('Collector must be instantiated with a options.type string property'); @@ -200,21 +177,5 @@ export class Collector< this.fetch = fetch; this.isReady = typeof isReady === 'function' ? isReady : () => true; this.extendFetchContext = extendFetchContext; - this._formatForBulkUpload = formatForBulkUpload; - } - - public formatForBulkUpload(result: TFetchReturn) { - if (this._formatForBulkUpload) { - return this._formatForBulkUpload(result); - } else { - return this.defaultFormatterForBulkUpload(result); - } - } - - protected defaultFormatterForBulkUpload(result: TFetchReturn) { - return { - type: this.type, - payload: (result as unknown) as UFormatBulkUploadPayload, - }; } } diff --git a/src/plugins/usage_collection/server/collector/collector_set.test.ts b/src/plugins/usage_collection/server/collector/collector_set.test.ts index fc17ce131430c..90a69043e0635 100644 --- a/src/plugins/usage_collection/server/collector/collector_set.test.ts +++ b/src/plugins/usage_collection/server/collector/collector_set.test.ts @@ -20,7 +20,7 @@ import { noop } from 'lodash'; import { Collector } from './collector'; import { CollectorSet } from './collector_set'; -import { UsageCollector, UsageCollectorOptions } from './usage_collector'; +import { UsageCollector } from './usage_collector'; import { elasticsearchServiceMock, loggingSystemMock, @@ -163,29 +163,6 @@ describe('CollectorSet', () => { }, ]); }); - - it('should infer the types from the implementations of fetch and formatForBulkUpload', async () => { - const collectors = new CollectorSet({ logger }); - collectors.registerCollector( - new Collector(logger, { - type: 'MY_TEST_COLLECTOR', - fetch: () => ({ test: 1 }), - formatForBulkUpload: (result) => ({ - type: 'MY_TEST_COLLECTOR', - payload: { test: result.test * 2 }, - }), - isReady: () => true, - }) - ); - - const result = await collectors.bulkFetch(mockCallCluster, mockEsClient, mockSoClient, req); - expect(result).toStrictEqual([ - { - type: 'MY_TEST_COLLECTOR', - result: { test: 1 }, // It matches the return of `fetch`. `formatForBulkUpload` is used later on - }, - ]); - }); }); describe('toApiFieldNames', () => { @@ -253,29 +230,6 @@ describe('CollectorSet', () => { }); }); - describe('isUsageCollector', () => { - const collectorOptions: UsageCollectorOptions = { - type: 'MY_TEST_COLLECTOR', - fetch: () => ({ test: 1 }), - isReady: () => true, - schema: { test: { type: 'long' } }, - }; - - it('returns true only for UsageCollector instances', () => { - const collectors = new CollectorSet({ logger }); - const usageCollector = new UsageCollector(logger, collectorOptions); - const collector = new Collector(logger, collectorOptions); - const randomClass = new (class Random {})(); - expect(collectors.isUsageCollector(usageCollector)).toEqual(true); - expect(collectors.isUsageCollector(collector)).toEqual(false); - expect(collectors.isUsageCollector(randomClass)).toEqual(false); - expect(collectors.isUsageCollector({})).toEqual(false); - expect(collectors.isUsageCollector(null)).toEqual(false); - expect(collectors.isUsageCollector('')).toEqual(false); - expect(collectors.isUsageCollector(void 0)).toEqual(false); - }); - }); - describe('makeStatsCollector', () => { const collectorSet = new CollectorSet({ logger }); test('TS should hide kibanaRequest when not opted-in', () => { @@ -402,7 +356,7 @@ describe('CollectorSet', () => { return { test: kibanaRequest ? 1 : 0 }; }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, false>({ + collectorSet.makeUsageCollector<{ test: number }, false>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -415,7 +369,7 @@ describe('CollectorSet', () => { kibanaRequest: false, }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, false>({ + collectorSet.makeUsageCollector<{ test: number }, false>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -442,7 +396,7 @@ describe('CollectorSet', () => { kibanaRequest: true, }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, false>({ + collectorSet.makeUsageCollector<{ test: number }, false>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -460,7 +414,7 @@ describe('CollectorSet', () => { test('TS should allow `true` when types explicitly declare `true` and do not allow `false` or undefined', () => { // false is the default when at least 1 type is specified - collectorSet.makeUsageCollector<{ test: number }, unknown, true>({ + collectorSet.makeUsageCollector<{ test: number }, true>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -472,7 +426,7 @@ describe('CollectorSet', () => { kibanaRequest: true, }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, true>({ + collectorSet.makeUsageCollector<{ test: number }, true>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -485,7 +439,7 @@ describe('CollectorSet', () => { kibanaRequest: false, }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, true>({ + collectorSet.makeUsageCollector<{ test: number }, true>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -498,7 +452,7 @@ describe('CollectorSet', () => { kibanaRequest: undefined, }, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, true>({ + collectorSet.makeUsageCollector<{ test: number }, true>({ type: 'MY_TEST_COLLECTOR', isReady: () => true, schema: { test: { type: 'long' } }, @@ -509,7 +463,7 @@ describe('CollectorSet', () => { // @ts-expect-error extendFetchContext: {}, }); - collectorSet.makeUsageCollector<{ test: number }, unknown, true>( + collectorSet.makeUsageCollector<{ test: number }, true>( // @ts-expect-error { type: 'MY_TEST_COLLECTOR', diff --git a/src/plugins/usage_collection/server/collector/collector_set.ts b/src/plugins/usage_collection/server/collector/collector_set.ts index cda4ce36d4e23..3555b05518fdb 100644 --- a/src/plugins/usage_collection/server/collector/collector_set.ts +++ b/src/plugins/usage_collection/server/collector/collector_set.ts @@ -29,8 +29,7 @@ import { import { Collector, CollectorOptions } from './collector'; import { UsageCollector, UsageCollectorOptions } from './usage_collector'; -type AnyCollector = Collector; -type AnyUsageCollector = UsageCollector; +type AnyCollector = Collector; interface CollectorSetConfig { logger: Logger; @@ -38,6 +37,22 @@ interface CollectorSetConfig { collectors?: AnyCollector[]; } +/** + * Public interface of the CollectorSet (makes it easier to mock only the public methods) + */ +export type CollectorSetPublic = Pick< + CollectorSet, + | 'makeStatsCollector' + | 'makeUsageCollector' + | 'registerCollector' + | 'getCollectorByType' + | 'areAllCollectorsReady' + | 'bulkFetch' + | 'bulkFetchUsage' + | 'toObject' + | 'toApiFieldNames' +>; + export class CollectorSet { private _waitingForAllCollectorsTimestamp?: number; private readonly logger: Logger; @@ -55,13 +70,12 @@ export class CollectorSet { */ public makeStatsCollector = < TFetchReturn, - TFormatForBulkUpload, WithKibanaRequest extends boolean, ExtraOptions extends object = {} >( - options: CollectorOptions + options: CollectorOptions ) => { - return new Collector(this.logger, options); + return new Collector(this.logger, options); }; /** @@ -70,32 +84,23 @@ export class CollectorSet { */ public makeUsageCollector = < TFetchReturn, - TFormatForBulkUpload = { usage: { [key: string]: TFetchReturn } }, // TODO: Right now, users will need to explicitly claim `true` for TS to allow `kibanaRequest` usage. // If we improve `telemetry-check-tools` so plugins do not need to specify TFetchReturn, // we'll be able to remove the type defaults and TS will successfully infer the config value as provided in JS. WithKibanaRequest extends boolean = false, ExtraOptions extends object = {} >( - options: UsageCollectorOptions< - TFetchReturn, - TFormatForBulkUpload, - WithKibanaRequest, - ExtraOptions - > + options: UsageCollectorOptions ) => { - return new UsageCollector( - this.logger, - options - ); + return new UsageCollector(this.logger, options); }; /** * Registers a collector to be used when collecting all the usage and stats data * @param collector Collector to be added to the set (previously created via `makeUsageCollector` or `makeStatsCollector`) */ - public registerCollector = ( - collector: Collector + public registerCollector = ( + collector: Collector ) => { // check instanceof if (!(collector instanceof Collector)) { @@ -118,10 +123,6 @@ export class CollectorSet { return [...this.collectors.values()].find((c) => c.type === type); }; - public isUsageCollector = (x: AnyUsageCollector | any): x is AnyUsageCollector => { - return x instanceof UsageCollector; - }; - public areAllCollectorsReady = async (collectorSet: CollectorSet = this) => { if (!(collectorSet instanceof CollectorSet)) { throw new Error( @@ -205,7 +206,7 @@ export class CollectorSet { /* * @return {new CollectorSet} */ - public getFilteredCollectorSet = (filter: (col: AnyCollector) => boolean) => { + private getFilteredCollectorSet = (filter: (col: AnyCollector) => boolean) => { const filtered = [...this.collectors.values()].filter(filter); return this.makeCollectorSetFromArray(filtered); }; @@ -267,16 +268,6 @@ export class CollectorSet { }, {}); }; - // TODO: remove - public map = (mapFn: any) => { - return [...this.collectors.values()].map(mapFn); - }; - - // TODO: remove - public some = (someFn: any) => { - return [...this.collectors.values()].some(someFn); - }; - private makeCollectorSetFromArray = (collectors: AnyCollector[]) => { return new CollectorSet({ logger: this.logger, diff --git a/src/plugins/usage_collection/server/collector/index.ts b/src/plugins/usage_collection/server/collector/index.ts index 2f8be884a8a7b..1bbb995154690 100644 --- a/src/plugins/usage_collection/server/collector/index.ts +++ b/src/plugins/usage_collection/server/collector/index.ts @@ -17,7 +17,7 @@ * under the License. */ -export { CollectorSet } from './collector_set'; +export { CollectorSet, CollectorSetPublic } from './collector_set'; export { Collector, AllowedSchemaTypes, diff --git a/src/plugins/usage_collection/server/collector/usage_collector.ts b/src/plugins/usage_collection/server/collector/usage_collector.ts index a042ea113d5cc..57f6d109d6d20 100644 --- a/src/plugins/usage_collection/server/collector/usage_collector.ts +++ b/src/plugins/usage_collection/server/collector/usage_collector.ts @@ -18,43 +18,24 @@ */ import { Logger } from 'src/core/server'; -import { KIBANA_STATS_TYPE } from '../../common/constants'; import { Collector, CollectorOptions } from './collector'; // Enforce the `schema` property for UsageCollectors export type UsageCollectorOptions< TFetchReturn = unknown, - UFormatBulkUploadPayload = { usage: { [key: string]: TFetchReturn } }, WithKibanaRequest extends boolean = false, ExtraOptions extends object = {} -> = CollectorOptions & - Required, 'schema'>>; +> = CollectorOptions & + Required, 'schema'>>; -export class UsageCollector< +export class UsageCollector extends Collector< TFetchReturn, - UFormatBulkUploadPayload = { usage: { [key: string]: TFetchReturn } }, - ExtraOptions extends object = {} -> extends Collector { + ExtraOptions +> { constructor( - public readonly log: Logger, - collectorOptions: UsageCollectorOptions< - TFetchReturn, - UFormatBulkUploadPayload, - any, - ExtraOptions - > + log: Logger, + collectorOptions: UsageCollectorOptions ) { super(log, collectorOptions); } - - protected defaultFormatterForBulkUpload(result: TFetchReturn) { - return { - type: KIBANA_STATS_TYPE, - payload: ({ - usage: { - [this.type]: result, - }, - } as unknown) as UFormatBulkUploadPayload, - }; - } } diff --git a/src/plugins/usage_collection/server/plugin.ts b/src/plugins/usage_collection/server/plugin.ts index 9a8876446d01e..31e4f0ea253ea 100644 --- a/src/plugins/usage_collection/server/plugin.ts +++ b/src/plugins/usage_collection/server/plugin.ts @@ -27,10 +27,10 @@ import { Plugin, } from 'src/core/server'; import { ConfigType } from './config'; -import { CollectorSet } from './collector'; +import { CollectorSet, CollectorSetPublic } from './collector'; import { setupRoutes } from './routes'; -export type UsageCollectionSetup = CollectorSet; +export type UsageCollectionSetup = CollectorSetPublic; export class UsageCollectionPlugin implements Plugin { private readonly logger: Logger; private savedObjects?: ISavedObjectsRepository; diff --git a/src/plugins/usage_collection/server/usage_collection.mock.ts b/src/plugins/usage_collection/server/usage_collection.mock.ts index 05dae8fa85164..fb0a2e56ff3c9 100644 --- a/src/plugins/usage_collection/server/usage_collection.mock.ts +++ b/src/plugins/usage_collection/server/usage_collection.mock.ts @@ -37,13 +37,6 @@ export const createUsageCollectionSetupMock = () => { bulkFetch: jest.fn(), bulkFetchUsage: jest.fn(), getCollectorByType: jest.fn(), - getFilteredCollectorSet: jest.fn(), - // @ts-ignore jest.fn doesn't play nice with type guards - isUsageCollector: jest.fn(), - makeCollectorSetFromArray: jest.fn(), - map: jest.fn(), - maximumWaitTimeForAllCollectorsInS: 0, - some: jest.fn(), toApiFieldNames: jest.fn(), toObject: jest.fn(), makeStatsCollector: jest.fn().mockImplementation((cfg) => new Collector(logger, cfg)), diff --git a/src/plugins/vis_type_timeseries/common/constants.ts b/src/plugins/vis_type_timeseries/common/constants.ts index bfcb5e8e15b9d..019afcba60000 100644 --- a/src/plugins/vis_type_timeseries/common/constants.ts +++ b/src/plugins/vis_type_timeseries/common/constants.ts @@ -22,4 +22,5 @@ export const INDEXES_SEPARATOR = ','; export const AUTO_INTERVAL = 'auto'; export const ROUTES = { VIS_DATA: '/api/metrics/vis/data', + FIELDS: '/api/metrics/fields', }; diff --git a/src/plugins/vis_type_timeseries/public/application/components/aggs/field_select.js b/src/plugins/vis_type_timeseries/public/application/components/aggs/field_select.js index a4168fd1398f1..b1ff749494b10 100644 --- a/src/plugins/vis_type_timeseries/public/application/components/aggs/field_select.js +++ b/src/plugins/vis_type_timeseries/public/application/components/aggs/field_select.js @@ -91,7 +91,7 @@ function FieldSelectUi({ } FieldSelectUi.defaultProps = { - indexPattern: '*', + indexPattern: '', disabled: false, restrict: [], placeholder: i18n.translate('visTypeTimeseries.fieldSelect.selectFieldPlaceholder', { diff --git a/src/plugins/vis_type_timeseries/public/application/components/annotations_editor.js b/src/plugins/vis_type_timeseries/public/application/components/annotations_editor.js index 34132e5f72716..3d38aa72fc271 100644 --- a/src/plugins/vis_type_timeseries/public/application/components/annotations_editor.js +++ b/src/plugins/vis_type_timeseries/public/application/components/annotations_editor.js @@ -43,13 +43,14 @@ import { EuiCode, EuiText, } from '@elastic/eui'; +import { i18n } from '@kbn/i18n'; import { FormattedMessage } from '@kbn/i18n/react'; function newAnnotation() { return { id: uuid.v1(), color: '#F00', - index_pattern: '*', + index_pattern: '', time_field: '@timestamp', icon: 'fa-tag', ignore_global_filters: 1, @@ -84,7 +85,7 @@ export class AnnotationsEditor extends Component { const defaults = { fields: '', template: '', - index_pattern: '*', + index_pattern: '', query_string: { query: '', language: getDefaultQueryLanguage() }, }; const model = { ...defaults, ...row }; @@ -100,6 +101,8 @@ export class AnnotationsEditor extends Component { const htmlId = htmlIdGenerator(model.id); const handleAdd = collectionActions.handleAdd.bind(null, this.props, newAnnotation); const handleDelete = collectionActions.handleDelete.bind(null, this.props, model); + const defaultIndexPattern = this.props.model.default_index_pattern; + return (
@@ -120,14 +123,22 @@ export class AnnotationsEditor extends Component { label={ } + helpText={ + defaultIndexPattern && + !model.index_pattern && + i18n.translate('visTypeTimeseries.annotationsEditor.searchByDefaultIndex', { + defaultMessage: 'Default index pattern is used. To query all indexes use *', + }) + } fullWidth > diff --git a/src/plugins/vis_type_timeseries/public/application/components/vis_editor.js b/src/plugins/vis_type_timeseries/public/application/components/vis_editor.js index 083ccaf8e5073..2cc50bd7efaeb 100644 --- a/src/plugins/vis_type_timeseries/public/application/components/vis_editor.js +++ b/src/plugins/vis_type_timeseries/public/application/components/vis_editor.js @@ -76,6 +76,19 @@ export class VisEditor extends Component { }); }, VIS_STATE_DEBOUNCE_DELAY); + debouncedFetchFields = debounce( + (extractedIndexPatterns) => { + if (this.abortControllerFetchFields) { + this.abortControllerFetchFields.abort(); + } + this.abortControllerFetchFields = new AbortController(); + + return fetchFields(extractedIndexPatterns, this.abortControllerFetchFields.signal); + }, + VIS_STATE_DEBOUNCE_DELAY, + { leading: true } + ); + handleChange = (partialModel) => { if (isEmpty(partialModel)) { return; @@ -94,7 +107,7 @@ export class VisEditor extends Component { const extractedIndexPatterns = extractIndexPatterns(nextModel); if (!isEqual(this.state.extractedIndexPatterns, extractedIndexPatterns)) { - fetchFields(extractedIndexPatterns).then((visFields) => + this.debouncedFetchFields(extractedIndexPatterns).then((visFields) => this.setState({ visFields, extractedIndexPatterns, diff --git a/src/plugins/vis_type_timeseries/public/application/lib/fetch_fields.js b/src/plugins/vis_type_timeseries/public/application/lib/fetch_fields.js index 6dd56a58418c5..a32ab71f36357 100644 --- a/src/plugins/vis_type_timeseries/public/application/lib/fetch_fields.js +++ b/src/plugins/vis_type_timeseries/public/application/lib/fetch_fields.js @@ -19,34 +19,40 @@ import { i18n } from '@kbn/i18n'; import { extractIndexPatterns } from '../../../common/extract_index_patterns'; import { getCoreStart } from '../../services'; +import { ROUTES } from '../../../common/constants'; -export async function fetchFields(indexPatterns = ['*']) { +export async function fetchFields(indexPatterns = [], signal) { const patterns = Array.isArray(indexPatterns) ? indexPatterns : [indexPatterns]; try { const indexFields = await Promise.all( - patterns.map((pattern) => { - return getCoreStart().http.get('/api/metrics/fields', { + patterns.map((pattern) => + getCoreStart().http.get(ROUTES.FIELDS, { query: { index: pattern, }, - }); - }) + signal, + }) + ) ); - const fields = patterns.reduce((cumulatedFields, currentPattern, index) => { - return { + + return patterns.reduce( + (cumulatedFields, currentPattern, index) => ({ ...cumulatedFields, [currentPattern]: indexFields[index], - }; - }, {}); - return fields; - } catch (error) { - getCoreStart().notifications.toasts.addDanger({ - title: i18n.translate('visTypeTimeseries.fetchFields.loadIndexPatternFieldsErrorMessage', { - defaultMessage: 'Unable to load index_pattern fields', }), - text: error.message, - }); + {} + ); + } catch (error) { + if (error.name !== 'AbortError') { + getCoreStart().notifications.toasts.addDanger({ + title: i18n.translate('visTypeTimeseries.fetchFields.loadIndexPatternFieldsErrorMessage', { + defaultMessage: 'Unable to load index_pattern fields', + }), + text: error.message, + }); + } } + return []; } export async function fetchIndexPatternFields({ params, fields = {} }) { diff --git a/src/plugins/vis_type_timeseries/server/routes/fields.ts b/src/plugins/vis_type_timeseries/server/routes/fields.ts index f9a600fa4b1f3..a9a890845d154 100644 --- a/src/plugins/vis_type_timeseries/server/routes/fields.ts +++ b/src/plugins/vis_type_timeseries/server/routes/fields.ts @@ -21,11 +21,12 @@ import { isBoom } from '@hapi/boom'; import { schema } from '@kbn/config-schema'; import { getFields } from '../lib/get_fields'; import { Framework } from '../plugin'; +import { ROUTES } from '../../common/constants'; export const fieldsRoutes = (framework: Framework) => { framework.router.get( { - path: '/api/metrics/fields', + path: ROUTES.FIELDS, validate: { query: schema.object({ index: schema.string() }), }, diff --git a/src/plugins/visualizations/public/legacy/build_pipeline.ts b/src/plugins/visualizations/public/legacy/build_pipeline.ts index d412ec918a71a..0c244876ca6a3 100644 --- a/src/plugins/visualizations/public/legacy/build_pipeline.ts +++ b/src/plugins/visualizations/public/legacy/build_pipeline.ts @@ -301,8 +301,10 @@ export const buildPipeline = async (vis: Vis, params: BuildPipelineParams) => { } else { const visConfig = { ...vis.params }; visConfig.dimensions = schemas; + visConfig.title = title; pipeline += `visualization type='${vis.type.name}' ${prepareJson('visConfig', visConfig)} + ${prepareJson('uiState', uiState)} metricsAtAllLevels=${vis.isHierarchical()} partialRows=${vis.params.showPartialRows || false} `; if (indexPattern) { diff --git a/test/functional/apps/discover/_date_nanos.js b/test/functional/apps/discover/_date_nanos.js index 9b076c8215754..1b5c033d67a43 100644 --- a/test/functional/apps/discover/_date_nanos.js +++ b/test/functional/apps/discover/_date_nanos.js @@ -27,8 +27,7 @@ export default function ({ getService, getPageObjects }) { const fromTime = 'Sep 22, 2019 @ 20:31:44.000'; const toTime = 'Sep 23, 2019 @ 03:31:44.000'; - // Failing: See https://github.com/elastic/kibana/issues/82035 - describe.skip('date_nanos', function () { + describe('date_nanos', function () { before(async function () { await esArchiver.loadIfNeeded('date_nanos'); await kibanaServer.uiSettings.replace({ defaultIndex: 'date-nanos' }); diff --git a/test/functional/apps/discover/_discover.js b/test/functional/apps/discover/_discover.js index fe5c04c001731..2270f3c815aaa 100644 --- a/test/functional/apps/discover/_discover.js +++ b/test/functional/apps/discover/_discover.js @@ -32,8 +32,7 @@ export default function ({ getService, getPageObjects }) { defaultIndex: 'logstash-*', }; - // Failing: See https://github.com/elastic/kibana/issues/82915 - describe.skip('discover test', function describeIndexTests() { + describe('discover test', function describeIndexTests() { before(async function () { log.debug('load kibana index with default index pattern'); await esArchiver.load('discover'); @@ -315,10 +314,13 @@ export default function ({ getService, getPageObjects }) { const getRequestTimestamp = async () => { const requestStats = await inspector.getTableData(); - const requestTimestamp = requestStats.filter((r) => - r[0].includes('Request timestamp') - )[0][1]; - return requestTimestamp; + const requestStatsRow = requestStats.filter( + (r) => r && r[0] && r[0].includes('Request timestamp') + ); + if (!requestStatsRow || !requestStatsRow[0] || !requestStatsRow[0][1]) { + return ''; + } + return requestStatsRow[0][1]; }; const requestTimestampBefore = await getRequestTimestamp(); @@ -327,7 +329,7 @@ export default function ({ getService, getPageObjects }) { log.debug( `Timestamp before: ${requestTimestampBefore}, Timestamp after: ${requestTimestampAfter}` ); - return requestTimestampBefore !== requestTimestampAfter; + return requestTimestampAfter && requestTimestampBefore !== requestTimestampAfter; }); }); diff --git a/test/functional/apps/discover/_shared_links.js b/test/functional/apps/discover/_shared_links.js index 9cd92626f73bf..60058ead1101e 100644 --- a/test/functional/apps/discover/_shared_links.js +++ b/test/functional/apps/discover/_shared_links.js @@ -29,8 +29,7 @@ export default function ({ getService, getPageObjects }) { const toasts = getService('toasts'); const deployment = getService('deployment'); - // FLAKY: https://github.com/elastic/kibana/issues/80104 - describe.skip('shared links', function describeIndexTests() { + describe('shared links', function describeIndexTests() { let baseUrl; async function setup({ storeStateInSessionStorage }) { diff --git a/x-pack/plugins/apm/common/agent_name.test.ts b/x-pack/plugins/apm/common/agent_name.test.ts index f4ac2aa220e89..10afefc264ae9 100644 --- a/x-pack/plugins/apm/common/agent_name.test.ts +++ b/x-pack/plugins/apm/common/agent_name.test.ts @@ -4,43 +4,9 @@ * you may not use this file except in compliance with the Elastic License. */ -import { - getFirstTransactionType, - isJavaAgentName, - isRumAgentName, -} from './agent_name'; +import { isJavaAgentName, isRumAgentName } from './agent_name'; describe('agent name helpers', () => { - describe('getFirstTransactionType', () => { - describe('with no transaction types', () => { - expect(getFirstTransactionType([])).toBeUndefined(); - }); - - describe('with a non-rum agent', () => { - it('returns "request"', () => { - expect(getFirstTransactionType(['worker', 'request'], 'java')).toEqual( - 'request' - ); - }); - - describe('with no request types', () => { - it('returns the first type', () => { - expect( - getFirstTransactionType(['worker', 'shirker'], 'java') - ).toEqual('worker'); - }); - }); - }); - - describe('with a rum agent', () => { - it('returns "page-load"', () => { - expect( - getFirstTransactionType(['http-request', 'page-load'], 'js-base') - ).toEqual('page-load'); - }); - }); - }); - describe('isJavaAgentName', () => { describe('when the agent name is java', () => { it('returns true', () => { diff --git a/x-pack/plugins/apm/common/agent_name.ts b/x-pack/plugins/apm/common/agent_name.ts index 916fe65684a6b..7fb79aa59595b 100644 --- a/x-pack/plugins/apm/common/agent_name.ts +++ b/x-pack/plugins/apm/common/agent_name.ts @@ -5,10 +5,6 @@ */ import { AgentName } from '../typings/es_schemas/ui/fields/agent'; -import { - TRANSACTION_PAGE_LOAD, - TRANSACTION_REQUEST, -} from './transaction_types'; /* * Agent names can be any string. This list only defines the official agents @@ -50,26 +46,6 @@ export const RUM_AGENT_NAMES: AgentName[] = [ 'opentelemetry/webjs', ]; -function getDefaultTransactionTypeForAgentName(agentName?: string) { - return isRumAgentName(agentName) - ? TRANSACTION_PAGE_LOAD - : TRANSACTION_REQUEST; -} - -export function getFirstTransactionType( - transactionTypes: string[], - agentName?: string -) { - const defaultTransactionType = getDefaultTransactionTypeForAgentName( - agentName - ); - - return ( - transactionTypes.find((type) => type === defaultTransactionType) ?? - transactionTypes[0] - ); -} - export function isJavaAgentName( agentName: string | undefined ): agentName is 'java' { diff --git a/x-pack/plugins/apm/common/utils/formatters/datetime.test.ts b/x-pack/plugins/apm/common/utils/formatters/datetime.test.ts index 733fb7bb5eea1..76f01c170ba99 100644 --- a/x-pack/plugins/apm/common/utils/formatters/datetime.test.ts +++ b/x-pack/plugins/apm/common/utils/formatters/datetime.test.ts @@ -73,19 +73,37 @@ describe('date time formatters', () => { const dateRange = asRelativeDateTimeRange(start, end); expect(dateRange).toEqual('Oct 29, 2019, 10:01 - 15:01 (UTC+1)'); }); - }); - describe('MMM D, YYYY, HH:mm:ss - HH:mm:ss (UTC)', () => { it('range: 14 minutes', () => { const start = formatDateToTimezone('2019-10-29 10:01:01'); const end = formatDateToTimezone('2019-10-29 10:15:01'); const dateRange = asRelativeDateTimeRange(start, end); - expect(dateRange).toEqual('Oct 29, 2019, 10:01:01 - 10:15:01 (UTC+1)'); + expect(dateRange).toEqual('Oct 29, 2019, 10:01 - 10:15 (UTC+1)'); }); it('range: 5 minutes', () => { const start = formatDateToTimezone('2019-10-29 10:01:01'); const end = formatDateToTimezone('2019-10-29 10:06:01'); const dateRange = asRelativeDateTimeRange(start, end); - expect(dateRange).toEqual('Oct 29, 2019, 10:01:01 - 10:06:01 (UTC+1)'); + expect(dateRange).toEqual('Oct 29, 2019, 10:01 - 10:06 (UTC+1)'); + }); + it('range: 1 minute', () => { + const start = formatDateToTimezone('2019-10-29 10:01:01'); + const end = formatDateToTimezone('2019-10-29 10:02:01'); + const dateRange = asRelativeDateTimeRange(start, end); + expect(dateRange).toEqual('Oct 29, 2019, 10:01 - 10:02 (UTC+1)'); + }); + }); + describe('MMM D, YYYY, HH:mm:ss - HH:mm:ss (UTC)', () => { + it('range: 50 seconds', () => { + const start = formatDateToTimezone('2019-10-29 10:01:01'); + const end = formatDateToTimezone('2019-10-29 10:01:50'); + const dateRange = asRelativeDateTimeRange(start, end); + expect(dateRange).toEqual('Oct 29, 2019, 10:01:01 - 10:01:50 (UTC+1)'); + }); + it('range: 10 seconds', () => { + const start = formatDateToTimezone('2019-10-29 10:01:01'); + const end = formatDateToTimezone('2019-10-29 10:01:11'); + const dateRange = asRelativeDateTimeRange(start, end); + expect(dateRange).toEqual('Oct 29, 2019, 10:01:01 - 10:01:11 (UTC+1)'); }); }); describe('MMM D, YYYY, HH:mm:ss.SSS - HH:mm:ss.SSS (UTC)', () => { diff --git a/x-pack/plugins/apm/common/utils/formatters/datetime.ts b/x-pack/plugins/apm/common/utils/formatters/datetime.ts index da08b3f49edce..6da71512befc5 100644 --- a/x-pack/plugins/apm/common/utils/formatters/datetime.ts +++ b/x-pack/plugins/apm/common/utils/formatters/datetime.ts @@ -80,14 +80,14 @@ function getFormatsAccordingToDateDifference( return { dateFormat: dateFormatWithDays }; } - if (getDateDifference(start, end, 'hours') >= 5) { + if (getDateDifference(start, end, 'minutes') >= 1) { return { dateFormat: dateFormatWithDays, timeFormat: getTimeFormat('minutes'), }; } - if (getDateDifference(start, end, 'minutes') >= 5) { + if (getDateDifference(start, end, 'seconds') >= 10) { return { dateFormat: dateFormatWithDays, timeFormat: getTimeFormat('seconds'), @@ -121,8 +121,8 @@ export function asAbsoluteDateTime( * | >= 5 years | YYYY - YYYY | * | >= 5 months | MMM YYYY - MMM YYYY | * | > 1 day | MMM D, YYYY - MMM D, YYYY | - * | >= 5 hours | MMM D, YYYY, HH:mm - HH:mm (UTC) | - * | >= 5 minutes | MMM D, YYYY, HH:mm:ss - HH:mm:ss (UTC) | + * | >= 1 minute | MMM D, YYYY, HH:mm - HH:mm (UTC) | + * | >= 10 seconds | MMM D, YYYY, HH:mm:ss - HH:mm:ss (UTC) | * | default | MMM D, YYYY, HH:mm:ss.SSS - HH:mm:ss.SSS (UTC) | * * @param start timestamp diff --git a/x-pack/plugins/apm/public/components/alerting/TransactionDurationAlertTrigger/index.tsx b/x-pack/plugins/apm/public/components/alerting/TransactionDurationAlertTrigger/index.tsx index ce98354c94c7e..b7220de8079c9 100644 --- a/x-pack/plugins/apm/public/components/alerting/TransactionDurationAlertTrigger/index.tsx +++ b/x-pack/plugins/apm/public/components/alerting/TransactionDurationAlertTrigger/index.tsx @@ -11,7 +11,6 @@ import React from 'react'; import { ForLastExpression } from '../../../../../triggers_actions_ui/public'; import { ALERT_TYPES_CONFIG } from '../../../../common/alert_types'; import { useEnvironments } from '../../../hooks/useEnvironments'; -import { useServiceTransactionTypes } from '../../../hooks/useServiceTransactionTypes'; import { useUrlParams } from '../../../hooks/useUrlParams'; import { ServiceAlertTrigger } from '../ServiceAlertTrigger'; import { PopoverExpression } from '../ServiceAlertTrigger/PopoverExpression'; @@ -22,6 +21,7 @@ import { TransactionTypeField, IsAboveField, } from '../fields'; +import { useApmService } from '../../../hooks/use_apm_service'; interface AlertParams { windowSize: number; @@ -63,7 +63,7 @@ interface Props { export function TransactionDurationAlertTrigger(props: Props) { const { setAlertParams, alertParams, setAlertProperty } = props; const { urlParams } = useUrlParams(); - const transactionTypes = useServiceTransactionTypes(urlParams); + const { transactionTypes } = useApmService(); const { serviceName } = useParams<{ serviceName?: string }>(); const { start, end, transactionType } = urlParams; const { environmentOptions } = useEnvironments({ serviceName, start, end }); diff --git a/x-pack/plugins/apm/public/components/alerting/TransactionDurationAnomalyAlertTrigger/index.tsx b/x-pack/plugins/apm/public/components/alerting/TransactionDurationAnomalyAlertTrigger/index.tsx index 4f87e13104371..e13ed6c1bcd6f 100644 --- a/x-pack/plugins/apm/public/components/alerting/TransactionDurationAnomalyAlertTrigger/index.tsx +++ b/x-pack/plugins/apm/public/components/alerting/TransactionDurationAnomalyAlertTrigger/index.tsx @@ -10,7 +10,6 @@ import React from 'react'; import { ANOMALY_SEVERITY } from '../../../../../ml/common'; import { ALERT_TYPES_CONFIG } from '../../../../common/alert_types'; import { useEnvironments } from '../../../hooks/useEnvironments'; -import { useServiceTransactionTypes } from '../../../hooks/useServiceTransactionTypes'; import { useUrlParams } from '../../../hooks/useUrlParams'; import { ServiceAlertTrigger } from '../ServiceAlertTrigger'; import { PopoverExpression } from '../ServiceAlertTrigger/PopoverExpression'; @@ -24,6 +23,7 @@ import { ServiceField, TransactionTypeField, } from '../fields'; +import { useApmService } from '../../../hooks/use_apm_service'; interface Params { windowSize: number; @@ -47,7 +47,7 @@ interface Props { export function TransactionDurationAnomalyAlertTrigger(props: Props) { const { setAlertParams, alertParams, setAlertProperty } = props; const { urlParams } = useUrlParams(); - const transactionTypes = useServiceTransactionTypes(urlParams); + const { transactionTypes } = useApmService(); const { serviceName } = useParams<{ serviceName?: string }>(); const { start, end, transactionType } = urlParams; const { environmentOptions } = useEnvironments({ serviceName, start, end }); diff --git a/x-pack/plugins/apm/public/components/alerting/TransactionErrorRateAlertTrigger/index.tsx b/x-pack/plugins/apm/public/components/alerting/TransactionErrorRateAlertTrigger/index.tsx index a9ad212393ac4..464409ed332e8 100644 --- a/x-pack/plugins/apm/public/components/alerting/TransactionErrorRateAlertTrigger/index.tsx +++ b/x-pack/plugins/apm/public/components/alerting/TransactionErrorRateAlertTrigger/index.tsx @@ -8,7 +8,6 @@ import React from 'react'; import { ForLastExpression } from '../../../../../triggers_actions_ui/public'; import { ALERT_TYPES_CONFIG, AlertType } from '../../../../common/alert_types'; import { useEnvironments } from '../../../hooks/useEnvironments'; -import { useServiceTransactionTypes } from '../../../hooks/useServiceTransactionTypes'; import { useUrlParams } from '../../../hooks/useUrlParams'; import { ServiceAlertTrigger } from '../ServiceAlertTrigger'; @@ -19,6 +18,7 @@ import { EnvironmentField, IsAboveField, } from '../fields'; +import { useApmService } from '../../../hooks/use_apm_service'; interface AlertParams { windowSize: number; @@ -38,7 +38,7 @@ interface Props { export function TransactionErrorRateAlertTrigger(props: Props) { const { setAlertParams, alertParams, setAlertProperty } = props; const { urlParams } = useUrlParams(); - const transactionTypes = useServiceTransactionTypes(urlParams); + const { transactionTypes } = useApmService(); const { serviceName } = useParams<{ serviceName?: string }>(); const { start, end, transactionType } = urlParams; const { environmentOptions } = useEnvironments({ serviceName, start, end }); diff --git a/x-pack/plugins/apm/public/components/app/Main/route_config/index.tsx b/x-pack/plugins/apm/public/components/app/Main/route_config/index.tsx index 63fb69d6d7cbf..ce8f2b0ba611a 100644 --- a/x-pack/plugins/apm/public/components/app/Main/route_config/index.tsx +++ b/x-pack/plugins/apm/public/components/app/Main/route_config/index.tsx @@ -7,6 +7,7 @@ import { i18n } from '@kbn/i18n'; import React from 'react'; import { Redirect, RouteComponentProps } from 'react-router-dom'; +import { ApmServiceContextProvider } from '../../../../context/apm_service_context'; import { UNIDENTIFIED_SERVICE_NODES_LABEL } from '../../../../../common/i18n'; import { SERVICE_NODE_NAME_MISSING } from '../../../../../common/service_nodes'; import { APMRouteDefinition } from '../../../../application/routes'; @@ -227,19 +228,19 @@ export const routes: APMRouteDefinition[] = [ breadcrumb: i18n.translate('xpack.apm.breadcrumb.overviewTitle', { defaultMessage: 'Overview', }), - component: ServiceDetailsOverview, + component: withApmServiceContext(ServiceDetailsOverview), } as APMRouteDefinition<{ serviceName: string }>, // errors { exact: true, path: '/services/:serviceName/errors/:groupId', - component: ErrorGroupDetails, + component: withApmServiceContext(ErrorGroupDetails), breadcrumb: ({ match }) => match.params.groupId, } as APMRouteDefinition<{ groupId: string; serviceName: string }>, { exact: true, path: '/services/:serviceName/errors', - component: ServiceDetailsErrors, + component: withApmServiceContext(ServiceDetailsErrors), breadcrumb: i18n.translate('xpack.apm.breadcrumb.errorsTitle', { defaultMessage: 'Errors', }), @@ -248,7 +249,7 @@ export const routes: APMRouteDefinition[] = [ { exact: true, path: '/services/:serviceName/transactions', - component: ServiceDetailsTransactions, + component: withApmServiceContext(ServiceDetailsTransactions), breadcrumb: i18n.translate('xpack.apm.breadcrumb.transactionsTitle', { defaultMessage: 'Transactions', }), @@ -257,7 +258,7 @@ export const routes: APMRouteDefinition[] = [ { exact: true, path: '/services/:serviceName/metrics', - component: ServiceDetailsMetrics, + component: withApmServiceContext(ServiceDetailsMetrics), breadcrumb: i18n.translate('xpack.apm.breadcrumb.metricsTitle', { defaultMessage: 'Metrics', }), @@ -266,7 +267,7 @@ export const routes: APMRouteDefinition[] = [ { exact: true, path: '/services/:serviceName/nodes', - component: ServiceDetailsNodes, + component: withApmServiceContext(ServiceDetailsNodes), breadcrumb: i18n.translate('xpack.apm.breadcrumb.nodesTitle', { defaultMessage: 'JVMs', }), @@ -275,7 +276,7 @@ export const routes: APMRouteDefinition[] = [ { exact: true, path: '/services/:serviceName/nodes/:serviceNodeName/metrics', - component: ServiceNodeMetrics, + component: withApmServiceContext(ServiceNodeMetrics), breadcrumb: ({ match }) => { const { serviceNodeName } = match.params; @@ -289,12 +290,20 @@ export const routes: APMRouteDefinition[] = [ { exact: true, path: '/services/:serviceName/transactions/view', - component: TransactionDetails, + component: withApmServiceContext(TransactionDetails), breadcrumb: ({ location }) => { const query = toQuery(location.search); return query.transactionName as string; }, }, + { + exact: true, + path: '/services/:serviceName/service-map', + component: withApmServiceContext(ServiceDetailsServiceMap), + breadcrumb: i18n.translate('xpack.apm.breadcrumb.serviceMapTitle', { + defaultMessage: 'Service Map', + }), + }, { exact: true, path: '/link-to/trace/:traceId', @@ -309,14 +318,6 @@ export const routes: APMRouteDefinition[] = [ defaultMessage: 'Service Map', }), }, - { - exact: true, - path: '/services/:serviceName/service-map', - component: ServiceDetailsServiceMap, - breadcrumb: i18n.translate('xpack.apm.breadcrumb.serviceMapTitle', { - defaultMessage: 'Service Map', - }), - }, { exact: true, path: '/settings/customize-ui', @@ -337,3 +338,13 @@ export const routes: APMRouteDefinition[] = [ ), }, ]; + +function withApmServiceContext(WrappedComponent: React.ComponentType) { + return (props: any) => { + return ( + + + + ); + }; +} diff --git a/x-pack/plugins/apm/public/components/app/service_details/service_detail_tabs.tsx b/x-pack/plugins/apm/public/components/app/service_details/service_detail_tabs.tsx index 92eb3753e7989..003bd6ba4c122 100644 --- a/x-pack/plugins/apm/public/components/app/service_details/service_detail_tabs.tsx +++ b/x-pack/plugins/apm/public/components/app/service_details/service_detail_tabs.tsx @@ -9,7 +9,6 @@ import { i18n } from '@kbn/i18n'; import React, { ReactNode } from 'react'; import { isJavaAgentName, isRumAgentName } from '../../../../common/agent_name'; import { enableServiceOverview } from '../../../../common/ui_settings_keys'; -import { useAgentName } from '../../../hooks/useAgentName'; import { useApmPluginContext } from '../../../hooks/useApmPluginContext'; import { useErrorOverviewHref } from '../../shared/Links/apm/ErrorOverviewLink'; import { useMetricOverviewHref } from '../../shared/Links/apm/MetricOverviewLink'; @@ -24,6 +23,7 @@ import { ServiceMetrics } from '../service_metrics'; import { ServiceNodeOverview } from '../ServiceNodeOverview'; import { ServiceOverview } from '../service_overview'; import { TransactionOverview } from '../transaction_overview'; +import { useApmService } from '../../../hooks/use_apm_service'; interface Tab { key: string; @@ -44,7 +44,7 @@ interface Props { } export function ServiceDetailTabs({ serviceName, tab }: Props) { - const { agentName } = useAgentName(); + const { agentName } = useApmService(); const { uiSettings } = useApmPluginContext().core; const overviewTab = { diff --git a/x-pack/plugins/apm/public/components/app/service_node_metrics/index.tsx b/x-pack/plugins/apm/public/components/app/service_node_metrics/index.tsx index a886c3f29d57c..11de40b47ff86 100644 --- a/x-pack/plugins/apm/public/components/app/service_node_metrics/index.tsx +++ b/x-pack/plugins/apm/public/components/app/service_node_metrics/index.tsx @@ -23,10 +23,10 @@ import { RouteComponentProps } from 'react-router-dom'; import styled from 'styled-components'; import { SERVICE_NODE_NAME_MISSING } from '../../../../common/service_nodes'; import { ChartPointerEventContextProvider } from '../../../context/chart_pointer_event_context'; -import { useAgentName } from '../../../hooks/useAgentName'; import { FETCH_STATUS, useFetcher } from '../../../hooks/useFetcher'; import { useServiceMetricCharts } from '../../../hooks/useServiceMetricCharts'; import { useUrlParams } from '../../../hooks/useUrlParams'; +import { useApmService } from '../../../hooks/use_apm_service'; import { px, truncate, unit } from '../../../style/variables'; import { ApmHeader } from '../../shared/ApmHeader'; import { MetricsChart } from '../../shared/charts/metrics_chart'; @@ -58,7 +58,7 @@ type ServiceNodeMetricsProps = RouteComponentProps<{ export function ServiceNodeMetrics({ match }: ServiceNodeMetricsProps) { const { urlParams, uiFilters } = useUrlParams(); const { serviceName, serviceNodeName } = match.params; - const { agentName } = useAgentName(); + const { agentName } = useApmService(); const { data } = useServiceMetricCharts( urlParams, agentName, diff --git a/x-pack/plugins/apm/public/components/app/service_overview/index.tsx b/x-pack/plugins/apm/public/components/app/service_overview/index.tsx index ddf3107a8ab1e..15125128d9781 100644 --- a/x-pack/plugins/apm/public/components/app/service_overview/index.tsx +++ b/x-pack/plugins/apm/public/components/app/service_overview/index.tsx @@ -21,6 +21,7 @@ import { TransactionErrorRateChart } from '../../shared/charts/transaction_error import { ServiceMapLink } from '../../shared/Links/apm/ServiceMapLink'; import { SearchBar } from '../../shared/search_bar'; import { ServiceOverviewErrorsTable } from './service_overview_errors_table'; +import { ServiceOverviewThroughputChart } from './service_overview_throughput_chart'; import { ServiceOverviewTransactionsTable } from './service_overview_transactions_table'; import { TableLinkFlexItem } from './table_link_flex_item'; @@ -64,18 +65,7 @@ export function ServiceOverview({ - - -

- {i18n.translate( - 'xpack.apm.serviceOverview.trafficChartTitle', - { - defaultMessage: 'Traffic', - } - )} -

- - + diff --git a/x-pack/plugins/apm/public/components/app/service_overview/service_overview.test.tsx b/x-pack/plugins/apm/public/components/app/service_overview/service_overview.test.tsx index e4ef7428ba8d4..b364f027538a6 100644 --- a/x-pack/plugins/apm/public/components/app/service_overview/service_overview.test.tsx +++ b/x-pack/plugins/apm/public/components/app/service_overview/service_overview.test.tsx @@ -72,6 +72,7 @@ describe('ServiceOverview', () => { sort: { direction: 'desc', field: 'test field' }, }, totalItemCount: 0, + throughput: [], }, refetch: () => {}, status: FETCH_STATUS.SUCCESS, diff --git a/x-pack/plugins/apm/public/components/app/service_overview/service_overview_throughput_chart.tsx b/x-pack/plugins/apm/public/components/app/service_overview/service_overview_throughput_chart.tsx new file mode 100644 index 0000000000000..94d92bfbe89dd --- /dev/null +++ b/x-pack/plugins/apm/public/components/app/service_overview/service_overview_throughput_chart.tsx @@ -0,0 +1,80 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { EuiPanel, EuiTitle } from '@elastic/eui'; +import { i18n } from '@kbn/i18n'; +import React from 'react'; +import { useParams } from 'react-router-dom'; +import { asTransactionRate } from '../../../../common/utils/formatters'; +import { useFetcher } from '../../../hooks/useFetcher'; +import { useTheme } from '../../../hooks/useTheme'; +import { useUrlParams } from '../../../hooks/useUrlParams'; +import { useApmService } from '../../../hooks/use_apm_service'; +import { callApmApi } from '../../../services/rest/createCallApmApi'; +import { TimeseriesChart } from '../../shared/charts/timeseries_chart'; + +export function ServiceOverviewThroughputChart({ + height, +}: { + height?: number; +}) { + const theme = useTheme(); + const { serviceName } = useParams<{ serviceName?: string }>(); + const { urlParams, uiFilters } = useUrlParams(); + const { transactionType } = useApmService(); + const { start, end } = urlParams; + + const { data, status } = useFetcher(() => { + if (serviceName && transactionType && start && end) { + return callApmApi({ + endpoint: 'GET /api/apm/services/{serviceName}/throughput', + params: { + path: { + serviceName, + }, + query: { + start, + end, + transactionType, + uiFilters: JSON.stringify(uiFilters), + }, + }, + }); + } + }, [serviceName, start, end, uiFilters, transactionType]); + + return ( + + +

+ {i18n.translate('xpack.apm.serviceOverview.throughtputChartTitle', { + defaultMessage: 'Traffic', + })} +

+ + + + ); +} diff --git a/x-pack/plugins/apm/public/components/app/transaction_overview/index.tsx b/x-pack/plugins/apm/public/components/app/transaction_overview/index.tsx index 45a6114c88afd..28a27c034265a 100644 --- a/x-pack/plugins/apm/public/components/app/transaction_overview/index.tsx +++ b/x-pack/plugins/apm/public/components/app/transaction_overview/index.tsx @@ -24,11 +24,9 @@ import { useTrackPageview } from '../../../../../observability/public'; import { Projection } from '../../../../common/projections'; import { TRANSACTION_PAGE_LOAD } from '../../../../common/transaction_types'; import { IUrlParams } from '../../../context/UrlParamsContext/types'; -import { useServiceTransactionTypes } from '../../../hooks/useServiceTransactionTypes'; import { useTransactionCharts } from '../../../hooks/useTransactionCharts'; import { useTransactionList } from '../../../hooks/useTransactionList'; import { useUrlParams } from '../../../hooks/useUrlParams'; -import { useTransactionType } from '../../../hooks/use_transaction_type'; import { TransactionCharts } from '../../shared/charts/transaction_charts'; import { ElasticDocsLink } from '../../shared/Links/ElasticDocsLink'; import { fromQuery, toQuery } from '../../shared/Links/url_helpers'; @@ -39,6 +37,7 @@ import { Correlations } from '../Correlations'; import { TransactionList } from './TransactionList'; import { useRedirect } from './useRedirect'; import { UserExperienceCallout } from './user_experience_callout'; +import { useApmService } from '../../../hooks/use_apm_service'; function getRedirectLocation({ location, @@ -69,8 +68,7 @@ interface TransactionOverviewProps { export function TransactionOverview({ serviceName }: TransactionOverviewProps) { const location = useLocation(); const { urlParams } = useUrlParams(); - const transactionType = useTransactionType(); - const serviceTransactionTypes = useServiceTransactionTypes(urlParams); + const { transactionType, transactionTypes } = useApmService(); // redirect to first transaction type useRedirect(getRedirectLocation({ location, transactionType, urlParams })); @@ -122,9 +120,7 @@ export function TransactionOverview({ serviceName }: TransactionOverviewProps) { - + diff --git a/x-pack/plugins/apm/public/components/app/transaction_overview/transaction_overview.test.tsx b/x-pack/plugins/apm/public/components/app/transaction_overview/transaction_overview.test.tsx index 2d7992feb3760..d4a8b3a46991c 100644 --- a/x-pack/plugins/apm/public/components/app/transaction_overview/transaction_overview.test.tsx +++ b/x-pack/plugins/apm/public/components/app/transaction_overview/transaction_overview.test.tsx @@ -11,10 +11,12 @@ import React from 'react'; import { Router } from 'react-router-dom'; import { createKibanaReactContext } from 'src/plugins/kibana_react/public'; import { MockApmPluginContextWrapper } from '../../../context/ApmPluginContext/MockApmPluginContext'; +import { ApmServiceContextProvider } from '../../../context/apm_service_context'; import { UrlParamsProvider } from '../../../context/UrlParamsContext'; import { IUrlParams } from '../../../context/UrlParamsContext/types'; import * as useFetcherHook from '../../../hooks/useFetcher'; -import * as useServiceTransactionTypesHook from '../../../hooks/useServiceTransactionTypes'; +import * as useServiceTransactionTypesHook from '../../../hooks/use_service_transaction_types'; +import * as useServiceAgentNameHook from '../../../hooks/use_service_agent_name'; import { disableConsoleWarning, renderWithTheme, @@ -37,19 +39,23 @@ function setup({ urlParams: IUrlParams; serviceTransactionTypes: string[]; }) { - const defaultLocation = { + history.replace({ pathname: '/services/foo/transactions', search: fromQuery(urlParams), - } as any; - - history.replace({ - ...defaultLocation, }); + // mock transaction types jest .spyOn(useServiceTransactionTypesHook, 'useServiceTransactionTypes') .mockReturnValue(serviceTransactionTypes); + // mock agent + jest.spyOn(useServiceAgentNameHook, 'useServiceAgentName').mockReturnValue({ + agentName: 'nodejs', + error: undefined, + status: useFetcherHook.FETCH_STATUS.SUCCESS, + }); + jest.spyOn(useFetcherHook, 'useFetcher').mockReturnValue({} as any); return renderWithTheme( @@ -57,7 +63,9 @@ function setup({ - + + + @@ -80,7 +88,7 @@ describe('TransactionOverview', () => { jest.clearAllMocks(); }); - describe('when no transaction type is given', () => { + describe('when no transaction type is given in urlParams', () => { it('should redirect to first type', () => { setup({ serviceTransactionTypes: ['firstType', 'secondType'], diff --git a/x-pack/plugins/apm/public/components/shared/charts/timeseries_chart.tsx b/x-pack/plugins/apm/public/components/shared/charts/timeseries_chart.tsx index ea6f2a4a233e5..a857707ca0c75 100644 --- a/x-pack/plugins/apm/public/components/shared/charts/timeseries_chart.tsx +++ b/x-pack/plugins/apm/public/components/shared/charts/timeseries_chart.tsx @@ -16,6 +16,7 @@ import { niceTimeFormatter, Placement, Position, + RectAnnotation, ScaleType, Settings, YDomainRange, @@ -27,12 +28,13 @@ import React, { useEffect } from 'react'; import { useHistory } from 'react-router-dom'; import { useChartTheme } from '../../../../../observability/public'; import { asAbsoluteDateTime } from '../../../../common/utils/formatters'; -import { TimeSeries } from '../../../../typings/timeseries'; +import { RectCoordinate, TimeSeries } from '../../../../typings/timeseries'; import { FETCH_STATUS } from '../../../hooks/useFetcher'; import { useTheme } from '../../../hooks/useTheme'; import { useUrlParams } from '../../../hooks/useUrlParams'; import { useAnnotations } from '../../../hooks/use_annotations'; import { useChartPointerEvent } from '../../../hooks/use_chart_pointer_event'; +import { AnomalySeries } from '../../../selectors/chart_selectors'; import { unit } from '../../../style/variables'; import { ChartContainer } from './chart_container'; import { onBrushEnd } from './helper/helper'; @@ -53,6 +55,7 @@ interface Props { yTickFormat?: (y: number) => string; showAnnotations?: boolean; yDomain?: YDomainRange; + anomalySeries?: AnomalySeries; } export function TimeseriesChart({ @@ -65,6 +68,7 @@ export function TimeseriesChart({ yTickFormat, showAnnotations = true, yDomain, + anomalySeries, }: Props) { const history = useHistory(); const chartRef = React.createRef(); @@ -102,7 +106,12 @@ export function TimeseriesChart({ onBrushEnd({ x, history })} - theme={chartTheme} + theme={{ + ...chartTheme, + areaSeriesStyle: { + line: { visible: false }, + }, + }} onPointerUpdate={setPointerEvent} externalPointerEvents={{ tooltip: { visible: true, placement: Placement.Bottom }, @@ -169,6 +178,36 @@ export function TimeseriesChart({ /> ); })} + + {anomalySeries?.bounderies && ( + false} + /> + )} + + {anomalySeries?.scores && ( + ({ + coordinates: { x0, x1 }, + }) + )} + style={{ fill: anomalySeries.scores.color }} + /> + )} ); diff --git a/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/index.tsx b/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/index.tsx index 3f8071ec39f0f..ac117bbbd922a 100644 --- a/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/index.tsx +++ b/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/index.tsx @@ -46,7 +46,7 @@ export function TransactionCharts({ }: TransactionChartProps) { const { transactionType } = urlParams; - const { responseTimeSeries, tpmSeries } = charts; + const { responseTimeSeries, tpmSeries, anomalySeries } = charts; const { formatter, toggleSerie } = useFormatter(responseTimeSeries); @@ -79,6 +79,7 @@ export function TransactionCharts({ id="transactionDuration" timeseries={responseTimeSeries || []} yLabelFormat={getResponseTimeTickFormatter(formatter)} + anomalySeries={anomalySeries} onToggleLegend={(serie) => { if (serie) { toggleSerie(serie); diff --git a/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/ml_header.tsx b/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/ml_header.tsx index 52b0470d31552..ee5cd8960d335 100644 --- a/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/ml_header.tsx +++ b/x-pack/plugins/apm/public/components/shared/charts/transaction_charts/ml_header.tsx @@ -84,7 +84,7 @@ export function MLHeader({ hasValidMlLicense, mlJobId }: Props) { transactionType={transactionType} > {i18n.translate('xpack.apm.metrics.transactionChart.viewJob', { - defaultMessage: 'View Job:', + defaultMessage: 'View Job', })} diff --git a/x-pack/plugins/apm/public/context/apm_service_context.test.tsx b/x-pack/plugins/apm/public/context/apm_service_context.test.tsx new file mode 100644 index 0000000000000..eb08cc22a0549 --- /dev/null +++ b/x-pack/plugins/apm/public/context/apm_service_context.test.tsx @@ -0,0 +1,70 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { getTransactionType } from './apm_service_context'; + +describe('getTransactionType', () => { + describe('with transaction type in url', () => { + it('returns the transaction type in the url ', () => { + expect( + getTransactionType({ + transactionTypes: ['worker', 'request'], + urlParams: { transactionType: 'custom' }, + agentName: 'nodejs', + }) + ).toBe('custom'); + }); + }); + + describe('with no transaction types', () => { + it('returns undefined', () => { + expect( + getTransactionType({ + transactionTypes: [], + urlParams: {}, + }) + ).toBeUndefined(); + }); + }); + + describe('with a non-rum agent', () => { + describe('with default transaction type', () => { + it('returns "request"', () => { + expect( + getTransactionType({ + transactionTypes: ['worker', 'request'], + urlParams: {}, + agentName: 'nodejs', + }) + ).toEqual('request'); + }); + }); + + describe('with no default transaction type', () => { + it('returns the first type', () => { + expect( + getTransactionType({ + transactionTypes: ['worker', 'custom'], + urlParams: {}, + agentName: 'nodejs', + }) + ).toEqual('worker'); + }); + }); + }); + + describe('with a rum agent', () => { + it('returns "page-load"', () => { + expect( + getTransactionType({ + transactionTypes: ['http-request', 'page-load'], + urlParams: {}, + agentName: 'js-base', + }) + ).toEqual('page-load'); + }); + }); +}); diff --git a/x-pack/plugins/apm/public/context/apm_service_context.tsx b/x-pack/plugins/apm/public/context/apm_service_context.tsx new file mode 100644 index 0000000000000..2f1b33dea5aa6 --- /dev/null +++ b/x-pack/plugins/apm/public/context/apm_service_context.tsx @@ -0,0 +1,72 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React, { createContext, ReactNode } from 'react'; +import { isRumAgentName } from '../../common/agent_name'; +import { + TRANSACTION_PAGE_LOAD, + TRANSACTION_REQUEST, +} from '../../common/transaction_types'; +import { useServiceTransactionTypes } from '../hooks/use_service_transaction_types'; +import { useUrlParams } from '../hooks/useUrlParams'; +import { useServiceAgentName } from '../hooks/use_service_agent_name'; +import { IUrlParams } from './UrlParamsContext/types'; + +export const APMServiceContext = createContext<{ + agentName?: string; + transactionType?: string; + transactionTypes: string[]; +}>({ transactionTypes: [] }); + +export function ApmServiceContextProvider({ + children, +}: { + children: ReactNode; +}) { + const { urlParams } = useUrlParams(); + const { agentName } = useServiceAgentName(); + const transactionTypes = useServiceTransactionTypes(); + const transactionType = getTransactionType({ + urlParams, + transactionTypes, + agentName, + }); + + return ( + + ); +} + +export function getTransactionType({ + urlParams, + transactionTypes, + agentName, +}: { + urlParams: IUrlParams; + transactionTypes: string[]; + agentName?: string; +}) { + if (urlParams.transactionType) { + return urlParams.transactionType; + } + + if (!agentName || transactionTypes.length === 0) { + return; + } + + // The default transaction type is "page-load" for RUM agents and "request" for all others + const defaultTransactionType = isRumAgentName(agentName) + ? TRANSACTION_PAGE_LOAD + : TRANSACTION_REQUEST; + + // If the default transaction type is not in transactionTypes the first in the list is returned + return transactionTypes.includes(defaultTransactionType) + ? defaultTransactionType + : transactionTypes[0]; +} diff --git a/x-pack/plugins/apm/public/hooks/useComponentId.tsx b/x-pack/plugins/apm/public/hooks/use_apm_service.ts similarity index 56% rename from x-pack/plugins/apm/public/hooks/useComponentId.tsx rename to x-pack/plugins/apm/public/hooks/use_apm_service.ts index c1de5c8ba3971..bc80c3771c39d 100644 --- a/x-pack/plugins/apm/public/hooks/useComponentId.tsx +++ b/x-pack/plugins/apm/public/hooks/use_apm_service.ts @@ -4,12 +4,9 @@ * you may not use this file except in compliance with the Elastic License. */ -import { useRef } from 'react'; +import { useContext } from 'react'; +import { APMServiceContext } from '../context/apm_service_context'; -let uniqueId = 0; -const getUniqueId = () => uniqueId++; - -export function useComponentId() { - const idRef = useRef(getUniqueId()); - return idRef.current; +export function useApmService() { + return useContext(APMServiceContext); } diff --git a/x-pack/plugins/apm/public/hooks/useAgentName.ts b/x-pack/plugins/apm/public/hooks/use_service_agent_name.ts similarity index 81% rename from x-pack/plugins/apm/public/hooks/useAgentName.ts rename to x-pack/plugins/apm/public/hooks/use_service_agent_name.ts index b226971762fab..199f14532f7b4 100644 --- a/x-pack/plugins/apm/public/hooks/useAgentName.ts +++ b/x-pack/plugins/apm/public/hooks/use_service_agent_name.ts @@ -3,16 +3,16 @@ * or more contributor license agreements. Licensed under the Elastic License; * you may not use this file except in compliance with the Elastic License. */ + import { useParams } from 'react-router-dom'; import { useFetcher } from './useFetcher'; import { useUrlParams } from './useUrlParams'; -export function useAgentName() { +export function useServiceAgentName() { const { serviceName } = useParams<{ serviceName?: string }>(); const { urlParams } = useUrlParams(); const { start, end } = urlParams; - - const { data: agentName, error, status } = useFetcher( + const { data, error, status } = useFetcher( (callApmApi) => { if (serviceName && start && end) { return callApmApi({ @@ -21,15 +21,11 @@ export function useAgentName() { path: { serviceName }, query: { start, end }, }, - }).then((res) => res.agentName); + }); } }, [serviceName, start, end] ); - return { - agentName, - status, - error, - }; + return { agentName: data?.agentName, status, error }; } diff --git a/x-pack/plugins/apm/public/hooks/useServiceTransactionTypes.tsx b/x-pack/plugins/apm/public/hooks/use_service_transaction_types.tsx similarity index 86% rename from x-pack/plugins/apm/public/hooks/useServiceTransactionTypes.tsx rename to x-pack/plugins/apm/public/hooks/use_service_transaction_types.tsx index 5f778e3d8834b..9d8892ac79b7d 100644 --- a/x-pack/plugins/apm/public/hooks/useServiceTransactionTypes.tsx +++ b/x-pack/plugins/apm/public/hooks/use_service_transaction_types.tsx @@ -5,13 +5,14 @@ */ import { useParams } from 'react-router-dom'; -import { IUrlParams } from '../context/UrlParamsContext/types'; import { useFetcher } from './useFetcher'; +import { useUrlParams } from './useUrlParams'; const INITIAL_DATA = { transactionTypes: [] }; -export function useServiceTransactionTypes(urlParams: IUrlParams) { +export function useServiceTransactionTypes() { const { serviceName } = useParams<{ serviceName?: string }>(); + const { urlParams } = useUrlParams(); const { start, end } = urlParams; const { data = INITIAL_DATA } = useFetcher( (callApmApi) => { diff --git a/x-pack/plugins/apm/public/hooks/use_transaction_breakdown.ts b/x-pack/plugins/apm/public/hooks/use_transaction_breakdown.ts index 686501c1eef4c..f1671ed7aa6d9 100644 --- a/x-pack/plugins/apm/public/hooks/use_transaction_breakdown.ts +++ b/x-pack/plugins/apm/public/hooks/use_transaction_breakdown.ts @@ -7,13 +7,13 @@ import { useParams } from 'react-router-dom'; import { useFetcher } from './useFetcher'; import { useUrlParams } from './useUrlParams'; -import { useTransactionType } from './use_transaction_type'; +import { useApmService } from './use_apm_service'; export function useTransactionBreakdown() { const { serviceName } = useParams<{ serviceName?: string }>(); const { urlParams, uiFilters } = useUrlParams(); const { start, end, transactionName } = urlParams; - const transactionType = useTransactionType(); + const { transactionType } = useApmService(); const { data = { timeseries: undefined }, error, status } = useFetcher( (callApmApi) => { diff --git a/x-pack/plugins/apm/public/hooks/use_transaction_type.ts b/x-pack/plugins/apm/public/hooks/use_transaction_type.ts deleted file mode 100644 index fd4e6516f9ca3..0000000000000 --- a/x-pack/plugins/apm/public/hooks/use_transaction_type.ts +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ - -import { getFirstTransactionType } from '../../common/agent_name'; -import { useAgentName } from './useAgentName'; -import { useServiceTransactionTypes } from './useServiceTransactionTypes'; -import { useUrlParams } from './useUrlParams'; - -/** - * Get either the transaction type from the URL parameters, "request" - * (for non-RUM agents), "page-load" (for RUM agents) if this service uses them, - * or the first available transaction type. - */ -export function useTransactionType() { - const { agentName } = useAgentName(); - const { urlParams } = useUrlParams(); - const transactionTypeFromUrlParams = urlParams.transactionType; - const transactionTypes = useServiceTransactionTypes(urlParams); - const firstTransactionType = getFirstTransactionType( - transactionTypes, - agentName - ); - - return transactionTypeFromUrlParams ?? firstTransactionType; -} diff --git a/x-pack/plugins/apm/public/selectors/chart_selectors.test.ts b/x-pack/plugins/apm/public/selectors/chart_selectors.test.ts index a17faebc9aefa..c9e6177f2c721 100644 --- a/x-pack/plugins/apm/public/selectors/chart_selectors.test.ts +++ b/x-pack/plugins/apm/public/selectors/chart_selectors.test.ts @@ -23,13 +23,10 @@ describe('chart selectors', () => { it('should return anomalyScoreSeries', () => { const data = [{ x0: 0, x: 10 }]; expect(getAnomalyScoreSeries(data)).toEqual({ - areaColor: 'rgba(231,102,76,0.1)', - color: 'none', + color: '#e7664c', data: [{ x0: 0, x: 10 }], - hideLegend: true, - hideTooltipValue: true, title: 'Anomaly score', - type: 'areaMaxHeight', + type: 'rectAnnotation', }); }); }); @@ -55,9 +52,7 @@ describe('chart selectors', () => { }; it('should produce correct series', () => { - expect( - getResponseTimeSeries({ apmTimeseries, anomalyTimeseries: undefined }) - ).toEqual([ + expect(getResponseTimeSeries({ apmTimeseries })).toEqual([ { color: '#6092c0', data: [ @@ -92,10 +87,7 @@ describe('chart selectors', () => { }); it('should return 3 series', () => { - expect( - getResponseTimeSeries({ apmTimeseries, anomalyTimeseries: undefined }) - .length - ).toBe(3); + expect(getResponseTimeSeries({ apmTimeseries }).length).toBe(3); }); }); diff --git a/x-pack/plugins/apm/public/selectors/chart_selectors.ts b/x-pack/plugins/apm/public/selectors/chart_selectors.ts index 663fbc9028108..2fdcaf9e4e675 100644 --- a/x-pack/plugins/apm/public/selectors/chart_selectors.ts +++ b/x-pack/plugins/apm/public/selectors/chart_selectors.ts @@ -30,10 +30,16 @@ export interface ITpmBucket { color: string; } +export interface AnomalySeries { + scores: TimeSeries; + bounderies: TimeSeries; +} + export interface ITransactionChartData { tpmSeries?: ITpmBucket[]; responseTimeSeries?: TimeSeries[]; mlJobId: string | undefined; + anomalySeries?: AnomalySeries; } const INITIAL_DATA: Partial = { @@ -58,16 +64,35 @@ export function getTransactionCharts( transactionCharts.responseTimeSeries = getResponseTimeSeries({ apmTimeseries, + }); + + transactionCharts.anomalySeries = getResponseTimeAnnomalySeries({ anomalyTimeseries, }); } return transactionCharts; } +function getResponseTimeAnnomalySeries({ + anomalyTimeseries, +}: { + anomalyTimeseries: TimeSeriesAPIResponse['anomalyTimeseries']; +}): AnomalySeries | undefined { + if (anomalyTimeseries) { + return { + bounderies: getAnomalyBoundariesSeries( + anomalyTimeseries.anomalyBoundaries + ), + scores: getAnomalyScoreSeries(anomalyTimeseries.anomalyScore), + }; + } +} + export function getResponseTimeSeries({ apmTimeseries, - anomalyTimeseries, -}: TimeSeriesAPIResponse) { +}: { + apmTimeseries: TimeSeriesAPIResponse['apmTimeseries']; +}) { const { overallAvgDuration } = apmTimeseries; const { avg, p95, p99 } = apmTimeseries.responseTimes; @@ -107,16 +132,6 @@ export function getResponseTimeSeries({ }, ]; - if (anomalyTimeseries) { - // insert after Avg. series - series.splice( - 1, - 0, - getAnomalyBoundariesSeries(anomalyTimeseries.anomalyBoundaries), - getAnomalyScoreSeries(anomalyTimeseries.anomalyScore) - ); - } - return series; } @@ -125,12 +140,9 @@ export function getAnomalyScoreSeries(data: RectCoordinate[]) { title: i18n.translate('xpack.apm.transactions.chart.anomalyScoreLabel', { defaultMessage: 'Anomaly score', }), - hideLegend: true, - hideTooltipValue: true, data, - type: 'areaMaxHeight', - color: 'none', - areaColor: rgba(theme.euiColorVis9, 0.1), + type: 'rectAnnotation', + color: theme.euiColorVis9, }; } @@ -142,12 +154,9 @@ function getAnomalyBoundariesSeries(data: Coordinate[]) { defaultMessage: 'Anomaly Boundaries', } ), - hideLegend: true, - hideTooltipValue: true, data, type: 'area', - color: 'none', - areaColor: rgba(theme.euiColorVis1, 0.1), + color: rgba(theme.euiColorVis1, 0.5), }; } diff --git a/x-pack/plugins/apm/server/lib/services/get_throughput.ts b/x-pack/plugins/apm/server/lib/services/get_throughput.ts new file mode 100644 index 0000000000000..0ac0ad17ef8fa --- /dev/null +++ b/x-pack/plugins/apm/server/lib/services/get_throughput.ts @@ -0,0 +1,84 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { ESFilter } from '../../../../../typings/elasticsearch'; +import { PromiseReturnType } from '../../../../observability/typings/common'; +import { + SERVICE_NAME, + TRANSACTION_TYPE, +} from '../../../common/elasticsearch_fieldnames'; +import { rangeFilter } from '../../../common/utils/range_filter'; +import { + getDocumentTypeFilterForAggregatedTransactions, + getProcessorEventForAggregatedTransactions, +} from '../helpers/aggregated_transactions'; +import { getBucketSize } from '../helpers/get_bucket_size'; +import { Setup, SetupTimeRange } from '../helpers/setup_request'; + +interface Options { + searchAggregatedTransactions: boolean; + serviceName: string; + setup: Setup & SetupTimeRange; + transactionType: string; +} + +type ESResponse = PromiseReturnType; + +function transform(response: ESResponse) { + const buckets = response.aggregations?.throughput?.buckets ?? []; + return buckets.map(({ key: x, doc_count: y }) => ({ x, y })); +} + +async function fetcher({ + searchAggregatedTransactions, + serviceName, + setup, + transactionType, +}: Options) { + const { start, end, apmEventClient } = setup; + const { intervalString } = getBucketSize({ start, end }); + const filter: ESFilter[] = [ + { term: { [SERVICE_NAME]: serviceName } }, + { term: { [TRANSACTION_TYPE]: transactionType } }, + { range: rangeFilter(start, end) }, + ...getDocumentTypeFilterForAggregatedTransactions( + searchAggregatedTransactions + ), + ...setup.esFilter, + ]; + + const params = { + apm: { + events: [ + getProcessorEventForAggregatedTransactions( + searchAggregatedTransactions + ), + ], + }, + body: { + size: 0, + query: { bool: { filter } }, + aggs: { + throughput: { + date_histogram: { + field: '@timestamp', + fixed_interval: intervalString, + min_doc_count: 0, + extended_bounds: { min: start, max: end }, + }, + }, + }, + }, + }; + + return apmEventClient.search(params); +} + +export async function getThroughput(options: Options) { + return { + throughput: transform(await fetcher(options)), + }; +} diff --git a/x-pack/plugins/apm/server/routes/create_apm_api.ts b/x-pack/plugins/apm/server/routes/create_apm_api.ts index 019482dd44485..9334ce60a3f9e 100644 --- a/x-pack/plugins/apm/server/routes/create_apm_api.ts +++ b/x-pack/plugins/apm/server/routes/create_apm_api.ts @@ -22,6 +22,7 @@ import { serviceAnnotationsRoute, serviceAnnotationsCreateRoute, serviceErrorGroupsRoute, + serviceThroughputRoute, serviceTransactionGroupsRoute, } from './services'; import { @@ -117,6 +118,7 @@ const createApmApi = () => { .add(serviceAnnotationsRoute) .add(serviceAnnotationsCreateRoute) .add(serviceErrorGroupsRoute) + .add(serviceThroughputRoute) .add(serviceTransactionGroupsRoute) // Agent configuration diff --git a/x-pack/plugins/apm/server/routes/services.ts b/x-pack/plugins/apm/server/routes/services.ts index 5e02fad2155ad..4c5738ecef581 100644 --- a/x-pack/plugins/apm/server/routes/services.ts +++ b/x-pack/plugins/apm/server/routes/services.ts @@ -20,6 +20,7 @@ import { getSearchAggregatedTransactions } from '../lib/helpers/aggregated_trans import { getServiceErrorGroups } from '../lib/services/get_service_error_groups'; import { toNumberRt } from '../../common/runtime_types/to_number_rt'; import { getServiceTransactionGroups } from '../lib/services/get_service_transaction_groups'; +import { getThroughput } from '../lib/services/get_throughput'; export const servicesRoute = createRoute({ endpoint: 'GET /api/apm/services', @@ -246,6 +247,36 @@ export const serviceErrorGroupsRoute = createRoute({ }, }); +export const serviceThroughputRoute = createRoute({ + endpoint: 'GET /api/apm/services/{serviceName}/throughput', + params: t.type({ + path: t.type({ + serviceName: t.string, + }), + query: t.intersection([ + t.type({ transactionType: t.string }), + uiFiltersRt, + rangeRt, + ]), + }), + options: { tags: ['access:apm'] }, + handler: async ({ context, request }) => { + const setup = await setupRequest(context, request); + const { serviceName } = context.params.path; + const { transactionType } = context.params.query; + const searchAggregatedTransactions = await getSearchAggregatedTransactions( + setup + ); + + return getThroughput({ + searchAggregatedTransactions, + serviceName, + setup, + transactionType, + }); + }, +}); + export const serviceTransactionGroupsRoute = createRoute({ endpoint: 'GET /api/apm/services/{serviceName}/overview_transaction_groups', params: t.type({ diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/constants/field_types.ts b/x-pack/plugins/enterprise_search/public/applications/shared/constants/field_types.ts new file mode 100644 index 0000000000000..9b8d7b1742f48 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/constants/field_types.ts @@ -0,0 +1,17 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +export const TEXT = 'text'; +export const NUMBER = 'number'; +export const DATE = 'date'; +export const GEOLOCATION = 'geolocation'; + +export const fieldTypeSelectOptions = [ + { value: TEXT, text: TEXT }, + { value: NUMBER, text: NUMBER }, + { value: DATE, text: DATE }, + { value: GEOLOCATION, text: GEOLOCATION }, +]; diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/constants.ts b/x-pack/plugins/enterprise_search/public/applications/shared/schema/constants.ts new file mode 100644 index 0000000000000..7d7d36ad09a27 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/constants.ts @@ -0,0 +1,83 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ +import { i18n } from '@kbn/i18n'; + +export const FIELD_NAME_CORRECT_NOTE = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.correct', + { + defaultMessage: 'Field names can only contain lowercase letters, numbers, and underscores', + } +); + +export const FIELD_NAME_CORRECTED_PREFIX = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.corrected', + { + defaultMessage: 'The field will be named', + } +); + +export const FIELD_NAME_MODAL_TITLE = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.title', + { + defaultMessage: 'Add a New Field', + } +); + +export const FIELD_NAME_MODAL_DESCRIPTION = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.description', + { + defaultMessage: 'Once added, a field cannot be removed from your schema.', + } +); + +export const FIELD_NAME_MODAL_CANCEL = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.cancel', + { + defaultMessage: 'Cancel', + } +); + +export const FIELD_NAME_MODAL_ADD_FIELD = i18n.translate( + 'xpack.enterpriseSearch.schema.addFieldModal.fieldNameNote.addField', + { + defaultMessage: 'Add field', + } +); + +export const ERROR_TABLE_ID_HEADER = i18n.translate( + 'xpack.enterpriseSearch.schema.errorsTable.heading.id', + { + defaultMessage: 'id', + } +); + +export const ERROR_TABLE_ERROR_HEADER = i18n.translate( + 'xpack.enterpriseSearch.schema.errorsTable.heading.error', + { + defaultMessage: 'Error', + } +); + +export const ERROR_TABLE_REVIEW_CONTROL = i18n.translate( + 'xpack.enterpriseSearch.schema.errorsTable.control.review', + { + defaultMessage: 'Review', + } +); + +export const ERROR_TABLE_VIEW_LINK = i18n.translate( + 'xpack.enterpriseSearch.schema.errorsTable.link.view', + { + defaultMessage: 'View', + } +); + +export const RECENTY_ADDED = i18n.translate( + 'xpack.enterpriseSearch.schema.existingField.status.recentlyAdded', + { + defaultMessage: 'Recently Added', + } +); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/index.ts b/x-pack/plugins/enterprise_search/public/applications/shared/schema/index.ts new file mode 100644 index 0000000000000..3c5d718422aa8 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/index.ts @@ -0,0 +1,8 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +export { SchemaAddFieldModal } from './schema_add_field_modal'; +export { SchemaExistingField } from './schema_existing_field'; diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.test.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.test.tsx new file mode 100644 index 0000000000000..e10d56ddc09b0 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.test.tsx @@ -0,0 +1,95 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; +import { shallow, mount } from 'enzyme'; + +import { NUMBER } from '../constants/field_types'; + +import { FIELD_NAME_CORRECTED_PREFIX } from './constants'; + +import { SchemaAddFieldModal } from './'; + +import { EuiFieldText, EuiModal, EuiSelect } from '@elastic/eui'; + +describe('SchemaAddFieldModal', () => { + const addNewField = jest.fn(); + const closeAddFieldModal = jest.fn(); + + const props = { + addNewField, + closeAddFieldModal, + }; + + const errors = { + addFieldFormErrors: ['error1', 'error2'], + }; + + const setState = jest.fn(); + const setStateMock: any = (initState: any) => [initState, setState]; + + beforeEach(() => { + jest.spyOn(React, 'useState').mockImplementationOnce(setStateMock); + setState(false); + }); + + it('renders', () => { + const wrapper = shallow(); + expect(wrapper.find(EuiModal)).toHaveLength(1); + }); + + // No matter what I try I can't get this to actually achieve coverage. + it('sets loading state in useEffect', () => { + setState(true); + const wrapper = mount(); + const input = wrapper.find(EuiFieldText); + + expect(input.prop('isLoading')).toEqual(false); + expect(setState).toHaveBeenCalledTimes(3); + expect(setState).toHaveBeenCalledWith(false); + }); + + it('handles input change - with non-formatted name', () => { + jest.spyOn(React, 'useState').mockImplementationOnce(setStateMock); + const wrapper = shallow(); + const input = wrapper.find(EuiFieldText); + input.simulate('change', { currentTarget: { value: 'foobar' } }); + + expect(wrapper.find('[data-test-subj="SchemaAddFieldNameRow"]').prop('helpText')).toEqual( + 'Field names can only contain lowercase letters, numbers, and underscores' + ); + }); + + it('handles input change - with formatted name', () => { + jest.spyOn(React, 'useState').mockImplementationOnce(setStateMock); + const wrapper = shallow(); + const input = wrapper.find(EuiFieldText); + input.simulate('change', { currentTarget: { value: 'foo-bar' } }); + + expect(wrapper.find('[data-test-subj="SchemaAddFieldNameRow"]').prop('helpText')).toEqual( + + {FIELD_NAME_CORRECTED_PREFIX} foo_bar + + ); + }); + + it('handles option change', () => { + const wrapper = shallow(); + wrapper.find(EuiSelect).simulate('change', { target: { value: NUMBER } }); + + expect(wrapper.find('[data-test-subj="SchemaSelect"]').prop('value')).toEqual(NUMBER); + }); + + it('handles form submission', () => { + jest.spyOn(React, 'useState').mockImplementationOnce(setStateMock); + const wrapper = shallow(); + const preventDefault = jest.fn(); + wrapper.find('form').simulate('submit', { preventDefault }); + + expect(addNewField).toHaveBeenCalled(); + expect(setState).toHaveBeenCalled(); + }); +}); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.tsx new file mode 100644 index 0000000000000..5cdd8be4016eb --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_add_field_modal.tsx @@ -0,0 +1,155 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React, { ChangeEvent, FormEvent, useEffect, useState } from 'react'; + +import { + EuiButton, + EuiButtonEmpty, + EuiFieldText, + EuiFlexGroup, + EuiFlexItem, + EuiForm, + EuiFormRow, + EuiModal, + EuiModalBody, + EuiModalFooter, + EuiModalHeader, + EuiModalHeaderTitle, + EuiOverlayMask, + EuiSelect, + EuiSpacer, +} from '@elastic/eui'; + +import { TEXT, fieldTypeSelectOptions } from '../constants/field_types'; + +import { + FIELD_NAME_CORRECT_NOTE, + FIELD_NAME_CORRECTED_PREFIX, + FIELD_NAME_MODAL_TITLE, + FIELD_NAME_MODAL_DESCRIPTION, + FIELD_NAME_MODAL_CANCEL, + FIELD_NAME_MODAL_ADD_FIELD, +} from './constants'; + +interface ISchemaAddFieldModalProps { + disableForm?: boolean; + addFieldFormErrors?: string[] | null; + addNewField(fieldName: string, newFieldType: string): void; + closeAddFieldModal(): void; +} + +export const SchemaAddFieldModal: React.FC = ({ + addNewField, + addFieldFormErrors, + closeAddFieldModal, + disableForm, +}) => { + const [loading, setLoading] = useState(false); + const [newFieldType, updateNewFieldType] = useState(TEXT); + const [formattedFieldName, setFormattedFieldName] = useState(''); + const [rawFieldName, setRawFieldName] = useState(''); + + useEffect(() => { + if (addFieldFormErrors) setLoading(false); + }, [addFieldFormErrors]); + + const handleChange = ({ currentTarget: { value } }: ChangeEvent) => { + setRawFieldName(value); + setFormattedFieldName(formatFieldName(value)); + }; + + const submitForm = (e: FormEvent) => { + e.preventDefault(); + addNewField(formattedFieldName, newFieldType); + setLoading(true); + }; + + const fieldNameNote = + rawFieldName !== formattedFieldName ? ( + <> + {FIELD_NAME_CORRECTED_PREFIX} {formattedFieldName} + + ) : ( + FIELD_NAME_CORRECT_NOTE + ); + + return ( + +
+ + + {FIELD_NAME_MODAL_TITLE} + + +

{FIELD_NAME_MODAL_DESCRIPTION}

+ + + + + + + + + + + updateNewFieldType(e.target.value)} + data-test-subj="SchemaSelect" + /> + + + + + + + {FIELD_NAME_MODAL_CANCEL} + + {FIELD_NAME_MODAL_ADD_FIELD} + + + +
+ + ); +}; + +const formatFieldName = (rawName: string) => + rawName + .trim() + .replace(/[^a-zA-Z0-9]+/g, '_') + .replace(/^[^a-zA-Z0-9]+/, '') + .replace(/[^a-zA-Z0-9]+$/, '') + .toLowerCase(); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.test.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.test.tsx new file mode 100644 index 0000000000000..c63fbe17ea2ad --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.test.tsx @@ -0,0 +1,48 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; +import { shallow } from 'enzyme'; + +import { EuiAccordion, EuiTableRow } from '@elastic/eui'; + +import { EuiLinkTo } from '../react_router_helpers'; +import { SchemaErrorsAccordion } from './schema_errors_accordion'; + +describe('SchemaErrorsAccordion', () => { + const props = { + fieldCoercionErrors: { + id: [ + { + external_id: 'foo', + error: 'this is an error', + }, + { + external_id: 'bar', + error: 'this is another error', + }, + ], + }, + schema: { + id: 'string', + name: 'boolean', + }, + }; + + it('renders', () => { + const wrapper = shallow(); + + expect(wrapper.find(EuiAccordion)).toHaveLength(1); + expect(wrapper.find(EuiTableRow)).toHaveLength(2); + expect(wrapper.find(EuiLinkTo)).toHaveLength(0); + }); + + it('renders document buttons', () => { + const wrapper = shallow(); + + expect(wrapper.find(EuiLinkTo)).toHaveLength(2); + }); +}); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.tsx new file mode 100644 index 0000000000000..98b5dbdd7b278 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_errors_accordion.tsx @@ -0,0 +1,133 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; + +import { + EuiAccordion, + EuiFlexGroup, + EuiFlexItem, + EuiTable, + EuiTableBody, + EuiTableHeader, + EuiTableHeaderCell, + EuiTableRow, + EuiTableRowCell, +} from '@elastic/eui'; + +import { EuiLinkTo } from '../react_router_helpers'; + +import { TruncatedContent } from '../truncate'; + +import { + ERROR_TABLE_ID_HEADER, + ERROR_TABLE_ERROR_HEADER, + ERROR_TABLE_REVIEW_CONTROL, + ERROR_TABLE_VIEW_LINK, +} from './constants'; + +interface IFieldCoercionError { + external_id: string; + error: string; +} + +interface IFieldCoercionErrors { + [key: string]: IFieldCoercionError[]; +} + +interface ISchemaErrorsAccordionProps { + fieldCoercionErrors: IFieldCoercionErrors; + schema: { [key: string]: string }; + itemId?: string; + getRoute?(itemId: string, externalId: string): string; +} + +export const SchemaErrorsAccordion: React.FC = ({ + fieldCoercionErrors, + schema, + itemId, + getRoute, +}) => ( + <> + {Object.keys(fieldCoercionErrors).map((fieldName, fieldNameIndex) => { + const errorInfos = fieldCoercionErrors[fieldName]; + + const accordionHeader = ( + + + + + + + {schema[fieldName]} + + + + {ERROR_TABLE_REVIEW_CONTROL} + + + ); + + return ( + + + + {ERROR_TABLE_ID_HEADER} + {ERROR_TABLE_ERROR_HEADER} + + + + {errorInfos.map((error, errorIndex) => { + const showViewButton = getRoute && itemId; + const documentPath = getRoute && itemId ? getRoute(itemId, error.external_id) : ''; + + const viewButton = showViewButton && ( + + + + {ERROR_TABLE_VIEW_LINK} + + + + ); + + return ( + + +
+ +
+ + + {error.error} + + {showViewButton ? viewButton : } + + ); + })} + + + + ); + })} + +); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.test.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.test.tsx new file mode 100644 index 0000000000000..d3040da476a91 --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.test.tsx @@ -0,0 +1,52 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; +import { shallow } from 'enzyme'; + +import { EuiSelect } from '@elastic/eui'; + +import { SchemaExistingField } from './'; + +describe('SchemaExistingField', () => { + const updateExistingFieldType = jest.fn(); + const props = { + fieldName: 'foo', + fieldType: 'field', + updateExistingFieldType, + }; + + it('renders', () => { + const wrapper = shallow(); + + expect(wrapper.find(EuiSelect)).toHaveLength(1); + }); + + it('renders no EuiSelect without props', () => { + const wrapper = shallow(); + + expect(wrapper.find(EuiSelect)).toHaveLength(0); + }); + + it('calls updateExistingFieldType when the select value is changed', () => { + const wrapper = shallow(); + wrapper.find(EuiSelect).simulate('change', { target: { value: 'bar' } }); + + expect(updateExistingFieldType).toHaveBeenCalledWith(props.fieldName, 'bar'); + }); + + it('doesn`t render fieldName when hidden', () => { + const wrapper = shallow(); + + expect(wrapper.find('.c-stui-engine-schema-field__name').contains(props.fieldName)).toBeFalsy(); + }); + + it('renders unconfirmed message', () => { + const wrapper = shallow(); + + expect(wrapper.find('.c-stui-engine-schema-field__status').exists()).toBeTruthy(); + }); +}); diff --git a/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.tsx b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.tsx new file mode 100644 index 0000000000000..99dd651f91f4b --- /dev/null +++ b/x-pack/plugins/enterprise_search/public/applications/shared/schema/schema_existing_field.tsx @@ -0,0 +1,57 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; + +import classNames from 'classnames'; + +import { EuiSelect } from '@elastic/eui'; + +import { fieldTypeSelectOptions } from '../constants/field_types'; + +import { RECENTY_ADDED } from './constants'; + +interface ISchemaExistingFieldProps { + disabled?: boolean; + fieldName: string; + fieldType?: string; + unconfirmed?: boolean; + hideName?: boolean; + updateExistingFieldType?(fieldName: string, fieldType: string): void; +} + +export const SchemaExistingField: React.FC = ({ + disabled, + fieldName, + fieldType, + unconfirmed, + hideName, + updateExistingFieldType, +}) => { + const fieldCssClass = classNames('c-stui-engine-schema-field', { + 'c-stui-engine-schema-field--recently-added': unconfirmed, + }); + + return ( +
+
{!hideName ? fieldName : ''}
+ {unconfirmed &&
{RECENTY_ADDED}
} + {fieldType && updateExistingFieldType && ( +
+ updateExistingFieldType(fieldName, e.target.value)} + data-test-subj="SchemaSelect" + /> +
+ )} +
+ ); +}; diff --git a/x-pack/plugins/fleet/common/types/models/epm.ts b/x-pack/plugins/fleet/common/types/models/epm.ts index 53e507f6fb494..7fd65ecdf238f 100644 --- a/x-pack/plugins/fleet/common/types/models/epm.ts +++ b/x-pack/plugins/fleet/common/types/models/epm.ts @@ -30,7 +30,7 @@ export type InstallSource = 'registry' | 'upload'; export type EpmPackageInstallStatus = 'installed' | 'installing'; -export type DetailViewPanelName = 'overview' | 'policies' | 'settings'; +export type DetailViewPanelName = 'overview' | 'policies' | 'settings' | 'custom'; export type ServiceName = 'kibana' | 'elasticsearch'; export type AgentAssetType = typeof agentAssetTypes; export type AssetType = KibanaAssetType | ElasticsearchAssetType | ValueOf; diff --git a/x-pack/plugins/fleet/public/applications/fleet/app.tsx b/x-pack/plugins/fleet/public/applications/fleet/app.tsx new file mode 100644 index 0000000000000..766ad961674af --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/app.tsx @@ -0,0 +1,261 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React, { memo, useEffect, useState } from 'react'; +import { AppMountParameters } from 'kibana/public'; +import { EuiCode, EuiEmptyPrompt, EuiErrorBoundary, EuiPanel } from '@elastic/eui'; +import { createHashHistory, History } from 'history'; +import { Router, Redirect, Route, Switch } from 'react-router-dom'; +import { FormattedMessage } from '@kbn/i18n/react'; +import { i18n } from '@kbn/i18n'; +import styled from 'styled-components'; +import useObservable from 'react-use/lib/useObservable'; +import { + ConfigContext, + FleetStatusProvider, + KibanaVersionContext, + sendGetPermissionsCheck, + sendSetup, + useBreadcrumbs, + useConfig, +} from './hooks'; +import { Error, Loading } from './components'; +import { IntraAppStateProvider } from './hooks/use_intra_app_state'; +import { PackageInstallProvider } from './sections/epm/hooks'; +import { PAGE_ROUTING_PATHS } from './constants'; +import { DefaultLayout, WithoutHeaderLayout } from './layouts'; +import { EPMApp } from './sections/epm'; +import { AgentPolicyApp } from './sections/agent_policy'; +import { DataStreamApp } from './sections/data_stream'; +import { FleetApp } from './sections/agents'; +import { IngestManagerOverview } from './sections/overview'; +import { ProtectedRoute } from './index'; +import { FleetConfigType, FleetStartServices } from '../../plugin'; +import { UIExtensionsStorage } from './types'; +import { KibanaContextProvider } from '../../../../../../src/plugins/kibana_react/public'; +import { EuiThemeProvider } from '../../../../xpack_legacy/common'; +import { UIExtensionsContext } from './hooks/use_ui_extension'; + +const ErrorLayout = ({ children }: { children: JSX.Element }) => ( + + + {children} + + +); + +const Panel = styled(EuiPanel)` + max-width: 500px; + margin-right: auto; + margin-left: auto; +`; + +export const WithPermissionsAndSetup: React.FC = memo(({ children }) => { + useBreadcrumbs('base'); + + const [isPermissionsLoading, setIsPermissionsLoading] = useState(false); + const [permissionsError, setPermissionsError] = useState(); + const [isInitialized, setIsInitialized] = useState(false); + const [initializationError, setInitializationError] = useState(null); + + useEffect(() => { + (async () => { + setIsPermissionsLoading(false); + setPermissionsError(undefined); + setIsInitialized(false); + setInitializationError(null); + try { + setIsPermissionsLoading(true); + const permissionsResponse = await sendGetPermissionsCheck(); + setIsPermissionsLoading(false); + if (permissionsResponse.data?.success) { + try { + const setupResponse = await sendSetup(); + if (setupResponse.error) { + setInitializationError(setupResponse.error); + } + } catch (err) { + setInitializationError(err); + } + setIsInitialized(true); + } else { + setPermissionsError(permissionsResponse.data?.error || 'REQUEST_ERROR'); + } + } catch (err) { + setPermissionsError('REQUEST_ERROR'); + } + })(); + }, []); + + if (isPermissionsLoading || permissionsError) { + return ( + + {isPermissionsLoading ? ( + + ) : permissionsError === 'REQUEST_ERROR' ? ( + + } + error={i18n.translate('xpack.fleet.permissionsRequestErrorMessageDescription', { + defaultMessage: 'There was a problem checking Fleet permissions', + })} + /> + ) : ( + + + {permissionsError === 'MISSING_SUPERUSER_ROLE' ? ( + + ) : ( + + )} + + } + body={ +

+ {permissionsError === 'MISSING_SUPERUSER_ROLE' ? ( + superuser }} + /> + ) : ( + + )} +

+ } + /> + + )} + + ); + } + + if (!isInitialized || initializationError) { + return ( + + {initializationError ? ( + + } + error={initializationError} + /> + ) : ( + + )} + + ); + } + + return <>{children}; +}); + +/** + * Fleet Application context all the way down to the Router, but with no permissions or setup checks + * and no routes defined + */ +export const FleetAppContext: React.FC<{ + basepath: string; + startServices: FleetStartServices; + config: FleetConfigType; + history: AppMountParameters['history']; + kibanaVersion: string; + extensions: UIExtensionsStorage; + /** For testing purposes only */ + routerHistory?: History; +}> = memo( + ({ + children, + startServices, + config, + history, + kibanaVersion, + extensions, + routerHistory = createHashHistory(), + }) => { + const isDarkMode = useObservable(startServices.uiSettings.get$('theme:darkMode')); + + return ( + + + + + + + + + + + + {children} + + + + + + + + + + + + ); + } +); + +export const AppRoutes = memo(() => { + const { agents } = useConfig(); + + return ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ); +}); diff --git a/x-pack/plugins/fleet/public/applications/fleet/hooks/use_url_pagination.ts b/x-pack/plugins/fleet/public/applications/fleet/hooks/use_url_pagination.ts index f9c351899fe0a..40539ed749285 100644 --- a/x-pack/plugins/fleet/public/applications/fleet/hooks/use_url_pagination.ts +++ b/x-pack/plugins/fleet/public/applications/fleet/hooks/use_url_pagination.ts @@ -69,15 +69,13 @@ const paginationFromUrlParams = (urlParams: UrlPaginationParams): Pagination => // Search params can appear multiple times in the URL, in which case the value for them, // once parsed, would be an array. In these case, we take the last value defined pagination.currentPage = Number( - (Array.isArray(urlParams.currentPage) - ? urlParams.currentPage[urlParams.currentPage.length - 1] - : urlParams.currentPage) ?? pagination.currentPage + (Array.isArray(urlParams.currentPage) ? urlParams.currentPage.pop() : urlParams.currentPage) ?? + pagination.currentPage ); pagination.pageSize = Number( - (Array.isArray(urlParams.pageSize) - ? urlParams.pageSize[urlParams.pageSize.length - 1] - : urlParams.pageSize) ?? pagination.pageSize + (Array.isArray(urlParams.pageSize) ? urlParams.pageSize.pop() : urlParams.pageSize) ?? + pagination.pageSize ) ?? pagination.pageSize; // If Current Page is not a valid positive integer, set it to 1 diff --git a/x-pack/plugins/fleet/public/applications/fleet/index.tsx b/x-pack/plugins/fleet/public/applications/fleet/index.tsx index 61a5f1eabc2af..35abda1490dce 100644 --- a/x-pack/plugins/fleet/public/applications/fleet/index.tsx +++ b/x-pack/plugins/fleet/public/applications/fleet/index.tsx @@ -3,36 +3,14 @@ * or more contributor license agreements. Licensed under the Elastic License; * you may not use this file except in compliance with the Elastic License. */ -import React, { memo, useEffect, useState } from 'react'; +import React from 'react'; import ReactDOM from 'react-dom'; -import useObservable from 'react-use/lib/useObservable'; -import { HashRouter as Router, Redirect, Switch, Route, RouteProps } from 'react-router-dom'; -import { i18n } from '@kbn/i18n'; -import { FormattedMessage } from '@kbn/i18n/react'; -import styled from 'styled-components'; -import { EuiErrorBoundary, EuiPanel, EuiEmptyPrompt, EuiCode } from '@elastic/eui'; +import { Redirect, Route, RouteProps } from 'react-router-dom'; import { CoreStart, AppMountParameters } from 'src/core/public'; -import { KibanaContextProvider } from '../../../../../../src/plugins/kibana_react/public'; -import { EuiThemeProvider } from '../../../../xpack_legacy/common'; import { FleetConfigType, FleetStartServices } from '../../plugin'; -import { PAGE_ROUTING_PATHS } from './constants'; -import { DefaultLayout, WithoutHeaderLayout } from './layouts'; -import { Loading, Error } from './components'; -import { IngestManagerOverview, EPMApp, AgentPolicyApp, FleetApp, DataStreamApp } from './sections'; -import { - ConfigContext, - useConfig, - useStartServices, - sendSetup, - sendGetPermissionsCheck, - licenseService, - KibanaVersionContext, -} from './hooks'; -import { PackageInstallProvider } from './sections/epm/hooks'; -import { FleetStatusProvider, useBreadcrumbs } from './hooks'; -import { IntraAppStateProvider } from './hooks/use_intra_app_state'; +import { licenseService } from './hooks'; import { UIExtensionsStorage } from './types'; -import { UIExtensionsContext } from './hooks/use_ui_extension'; +import { AppRoutes, FleetAppContext, WithPermissionsAndSetup } from './app'; export interface ProtectedRouteProps extends RouteProps { isAllowed?: boolean; @@ -47,213 +25,35 @@ export const ProtectedRoute: React.FunctionComponent = ({ return isAllowed ? : ; }; -const Panel = styled(EuiPanel)` - max-width: 500px; - margin-right: auto; - margin-left: auto; -`; - -const ErrorLayout = ({ children }: { children: JSX.Element }) => ( - - - {children} - - -); - -const IngestManagerRoutes = memo<{ history: AppMountParameters['history']; basepath: string }>( - ({ history, ...rest }) => { - useBreadcrumbs('base'); - const { agents } = useConfig(); - - const { notifications } = useStartServices(); - - const [isPermissionsLoading, setIsPermissionsLoading] = useState(false); - const [permissionsError, setPermissionsError] = useState(); - const [isInitialized, setIsInitialized] = useState(false); - const [initializationError, setInitializationError] = useState(null); - - useEffect(() => { - (async () => { - setIsPermissionsLoading(false); - setPermissionsError(undefined); - setIsInitialized(false); - setInitializationError(null); - try { - setIsPermissionsLoading(true); - const permissionsResponse = await sendGetPermissionsCheck(); - setIsPermissionsLoading(false); - if (permissionsResponse.data?.success) { - try { - const setupResponse = await sendSetup(); - if (setupResponse.error) { - setInitializationError(setupResponse.error); - } - } catch (err) { - setInitializationError(err); - } - setIsInitialized(true); - } else { - setPermissionsError(permissionsResponse.data?.error || 'REQUEST_ERROR'); - } - } catch (err) { - setPermissionsError('REQUEST_ERROR'); - } - })(); - }, []); - - if (isPermissionsLoading || permissionsError) { - return ( - - {isPermissionsLoading ? ( - - ) : permissionsError === 'REQUEST_ERROR' ? ( - - } - error={i18n.translate('xpack.fleet.permissionsRequestErrorMessageDescription', { - defaultMessage: 'There was a problem checking Fleet permissions', - })} - /> - ) : ( - - - {permissionsError === 'MISSING_SUPERUSER_ROLE' ? ( - - ) : ( - - )} - - } - body={ -

- {permissionsError === 'MISSING_SUPERUSER_ROLE' ? ( - superuser }} - /> - ) : ( - - )} -

- } - /> - - )} - - ); - } - - if (!isInitialized || initializationError) { - return ( - - {initializationError ? ( - - } - error={initializationError} - /> - ) : ( - - )} - - ); - } - - return ( - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ); - } -); - -const IngestManagerApp = ({ - basepath, - startServices, - config, - history, - kibanaVersion, - extensions, -}: { +interface FleetAppProps { basepath: string; startServices: FleetStartServices; config: FleetConfigType; history: AppMountParameters['history']; kibanaVersion: string; extensions: UIExtensionsStorage; -}) => { - const isDarkMode = useObservable(startServices.uiSettings.get$('theme:darkMode')); +} +const FleetApp = ({ + basepath, + startServices, + config, + history, + kibanaVersion, + extensions, +}: FleetAppProps) => { return ( - - - - - - - - - - - - - + + + + + ); }; @@ -265,7 +65,7 @@ export function renderApp( extensions: UIExtensionsStorage ) { ReactDOM.render( - RenderResult; + +/** + * Test Renderer that includes mocked services and interfaces used during Fleet applicaiton rendering. + * Any of the properties in this interface can be manipulated prior to `render()` if wanting to customize + * the rendering context. + */ +export interface TestRenderer { + /** History instance currently used by the Fleet UI Hash Router */ + history: History; + /** history instance provided to the Fleet plugin during application `mount()` */ + mountHistory: ScopedHistory; + startServices: MockedFleetStartServices; + config: FleetConfigType; + /** The Interface returned by the Fleet plugin `start()` phase */ + startInterface: MockedFleetStart; + kibanaVersion: string; + AppWrapper: React.FC; + render: UiRender; +} + +export const createTestRendererMock = (): TestRenderer => { + const basePath = '/mock'; + const extensions: UIExtensionsStorage = {}; + const startServices = createStartServices(basePath); + const testRendererMocks: TestRenderer = { + history: createHashHistory(), + mountHistory: new ScopedHistory(createMemoryHistory({ initialEntries: [basePath] }), basePath), + startServices, + config: createConfigurationMock(), + startInterface: createStartMock(extensions), + kibanaVersion: '8.0.0', + AppWrapper: memo(({ children }) => { + return ( + + {children} + + ); + }), + render: (ui, options) => { + let renderResponse: RenderResult; + act(() => { + renderResponse = reactRender(ui, { + wrapper: testRendererMocks.AppWrapper, + ...options, + }); + }); + return renderResponse!; + }, + }; + + return testRendererMocks; +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/fleet_start_services.tsx b/x-pack/plugins/fleet/public/applications/fleet/mock/fleet_start_services.tsx new file mode 100644 index 0000000000000..cc24d946e46af --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/fleet_start_services.tsx @@ -0,0 +1,56 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; +import { I18nProvider } from '@kbn/i18n/react'; +import { coreMock } from '../../../../../../../src/core/public/mocks'; +import { createStartDepsMock } from './plugin_dependencies'; +import { IStorage, Storage } from '../../../../../../../src/plugins/kibana_utils/public'; +import { MockedKeys } from '../../../../../../../packages/kbn-utility-types/jest/index'; +import { setHttpClient } from '../hooks/use_request'; +import { MockedFleetStartServices } from './types'; + +// Taken from core. See: src/plugins/kibana_utils/public/storage/storage.test.ts +const createMockStore = (): MockedKeys => { + let store: Record = {}; + return { + getItem: jest.fn().mockImplementation((key) => store[key]), + setItem: jest.fn().mockImplementation((key, value) => (store[key] = value)), + removeItem: jest.fn().mockImplementation((key: string) => delete store[key]), + clear: jest.fn().mockImplementation(() => (store = {})), + }; +}; + +const configureStartServices = (services: MockedFleetStartServices): void => { + // Store the http for use by useRequest + setHttpClient(services.http); + + // Set Fleet available capabilities + services.application.capabilities = { + ...services.application.capabilities, + fleet: { + read: true, + write: true, + }, + }; + + // Setup the `i18n.Context` component + services.i18n.Context.mockImplementation(({ children }: { children: React.ReactNode }) => ( + {children} + )); +}; + +export const createStartServices = (basePath: string = '/mock'): MockedFleetStartServices => { + const startServices: MockedFleetStartServices = { + ...coreMock.createStart({ basePath }), + ...createStartDepsMock(), + storage: new Storage(createMockStore()) as jest.Mocked, + }; + + configureStartServices(startServices); + + return startServices; +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/index.ts b/x-pack/plugins/fleet/public/applications/fleet/mock/index.ts new file mode 100644 index 0000000000000..6202f2cfee1fb --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/index.ts @@ -0,0 +1,12 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +export * from './create_test_renderer'; +export * from './plugin_configuration'; +export * from './plugin_dependencies'; +export * from './plugin_interfaces'; +export * from './fleet_start_services'; +export * from './types'; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_configuration.ts b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_configuration.ts new file mode 100644 index 0000000000000..735c1d11a9837 --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_configuration.ts @@ -0,0 +1,31 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { FleetConfigType } from '../../../plugin'; + +export const createConfigurationMock = (): FleetConfigType => { + return { + enabled: true, + registryUrl: '', + registryProxyUrl: '', + agents: { + enabled: true, + tlsCheckDisabled: true, + pollingRequestTimeout: 1000, + maxConcurrentConnections: 100, + kibana: { + host: '', + ca_sha256: '', + }, + elasticsearch: { + host: '', + ca_sha256: '', + }, + agentPolicyRolloutRateLimitIntervalMs: 100, + agentPolicyRolloutRateLimitRequestPerInterval: 1000, + }, + }; +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_dependencies.ts b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_dependencies.ts new file mode 100644 index 0000000000000..51de2970f9ba6 --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_dependencies.ts @@ -0,0 +1,24 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { dataPluginMock } from '../../../../../../../src/plugins/data/public/mocks'; +import { licensingMock } from '../../../../../licensing/public/mocks'; +import { homePluginMock } from '../../../../../../../src/plugins/home/public/mocks'; +import { MockedFleetSetupDeps, MockedFleetStartDeps } from './types'; + +export const createSetupDepsMock = (): MockedFleetSetupDeps => { + return { + licensing: licensingMock.createSetup(), + data: dataPluginMock.createSetupContract(), + home: homePluginMock.createSetupContract(), + }; +}; + +export const createStartDepsMock = (): MockedFleetStartDeps => { + return { + data: dataPluginMock.createStartContract(), + }; +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_interfaces.ts b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_interfaces.ts new file mode 100644 index 0000000000000..786702863b0d6 --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/plugin_interfaces.ts @@ -0,0 +1,16 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { UIExtensionsStorage } from '../types'; +import { createExtensionRegistrationCallback } from '../services/ui_extensions'; +import { MockedFleetStart } from './types'; + +export const createStartMock = (extensionsStorage: UIExtensionsStorage = {}): MockedFleetStart => { + return { + isInitialized: jest.fn().mockResolvedValue(true), + registerExtension: createExtensionRegistrationCallback(extensionsStorage), + }; +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/mock/types.ts b/x-pack/plugins/fleet/public/applications/fleet/mock/types.ts new file mode 100644 index 0000000000000..c5830b0a2a560 --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/mock/types.ts @@ -0,0 +1,16 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { MockedKeys } from '../../../../../../../packages/kbn-utility-types/jest/index'; +import { FleetSetupDeps, FleetStart, FleetStartDeps, FleetStartServices } from '../../../plugin'; + +export type MockedFleetStartServices = MockedKeys; + +export type MockedFleetSetupDeps = MockedKeys; + +export type MockedFleetStartDeps = MockedKeys; + +export type MockedFleetStart = MockedKeys; diff --git a/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/content.tsx b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/content.tsx index 62adad14a028c..b19a82d3100c5 100644 --- a/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/content.tsx +++ b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/content.tsx @@ -7,6 +7,7 @@ import { EuiFlexGroup, EuiFlexItem, EuiSpacer } from '@elastic/eui'; import React from 'react'; import styled from 'styled-components'; +import { Redirect } from 'react-router-dom'; import { DetailParams } from '.'; import { PackageInfo } from '../../../../types'; import { AssetsFacetGroup } from '../../components/assets_facet_group'; @@ -14,6 +15,9 @@ import { CenterColumn, LeftColumn, RightColumn } from './layout'; import { OverviewPanel } from './overview_panel'; import { PackagePoliciesPanel } from './package_policies_panel'; import { SettingsPanel } from './settings_panel'; +import { useUIExtension } from '../../../../hooks/use_ui_extension'; +import { ExtensionWrapper } from '../../../../components/extension_wrapper'; +import { useLink } from '../../../../hooks'; type ContentProps = PackageInfo & Pick; @@ -49,6 +53,9 @@ export function Content(props: ContentProps) { type ContentPanelProps = PackageInfo & Pick; export function ContentPanel(props: ContentPanelProps) { const { panel, name, version, assets, title, removable, latestVersion } = props; + const CustomView = useUIExtension(name, 'package-detail-custom'); + const { getPath } = useLink(); + switch (panel) { case 'settings': return ( @@ -63,6 +70,14 @@ export function ContentPanel(props: ContentPanelProps) { ); case 'policies': return ; + case 'custom': + return CustomView ? ( + + + + ) : ( + + ); case 'overview': default: return ; diff --git a/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.test.tsx b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.test.tsx new file mode 100644 index 0000000000000..9dfc1b5581533 --- /dev/null +++ b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.test.tsx @@ -0,0 +1,380 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { createTestRendererMock, MockedFleetStartServices, TestRenderer } from '../../../../mock'; +import { Detail } from './index'; +import React, { lazy, memo } from 'react'; +import { PAGE_ROUTING_PATHS, pagePathGetters } from '../../../../constants'; +import { Route } from 'react-router-dom'; +import { + GetFleetStatusResponse, + GetInfoResponse, +} from '../../../../../../../common/types/rest_spec'; +import { DetailViewPanelName, KibanaAssetType } from '../../../../../../../common/types/models'; +import { epmRouteService, fleetSetupRouteService } from '../../../../../../../common/services'; +import { act } from '@testing-library/react'; + +describe('when on integration detail', () => { + const detailPageUrlPath = pagePathGetters.integration_details({ pkgkey: 'nginx-0.3.7' }); + let testRenderer: TestRenderer; + let renderResult: ReturnType; + const render = () => + (renderResult = testRenderer.render( + + + + )); + + beforeEach(() => { + testRenderer = createTestRendererMock(); + mockApiCalls(testRenderer.startServices.http); + testRenderer.history.push(detailPageUrlPath); + }); + + describe('and a custom UI extension is NOT registered', () => { + beforeEach(() => render()); + + it('should show overview and settings tabs', () => { + const tabs: DetailViewPanelName[] = ['overview', 'settings']; + for (const tab of tabs) { + expect(renderResult.getByTestId(`tab-${tab}`)); + } + }); + + it('should not show a custom tab', () => { + expect(renderResult.queryByTestId('tab-custom')).toBeNull(); + }); + + it('should redirect if custom url is accessed', () => { + act(() => { + testRenderer.history.push( + pagePathGetters.integration_details({ pkgkey: 'nginx-0.3.7', panel: 'custom' }) + ); + }); + expect(testRenderer.history.location.pathname).toEqual(detailPageUrlPath); + }); + }); + + describe('and a custom UI extension is registered', () => { + // Because React Lazy components are loaded async (Promise), we setup this "watcher" Promise + // that is `resolved` once the lazy components actually renders. + let lazyComponentWasRendered: Promise; + + beforeEach(() => { + let setWasRendered: () => void; + lazyComponentWasRendered = new Promise((resolve) => { + setWasRendered = resolve; + }); + + const CustomComponent = lazy(async () => { + return { + default: memo(() => { + setWasRendered(); + return
hello
; + }), + }; + }); + + testRenderer.startInterface.registerExtension({ + package: 'nginx', + view: 'package-detail-custom', + component: CustomComponent, + }); + + render(); + }); + + afterEach(() => { + // @ts-ignore + lazyComponentWasRendered = undefined; + }); + + it('should display "custom" tab in navigation', () => { + expect(renderResult.getByTestId('tab-custom')); + }); + + it('should display custom content when tab is clicked', async () => { + act(() => { + testRenderer.history.push( + pagePathGetters.integration_details({ pkgkey: 'nginx-0.3.7', panel: 'custom' }) + ); + }); + await lazyComponentWasRendered; + expect(renderResult.getByTestId('custom-hello')); + }); + }); +}); + +const mockApiCalls = (http: MockedFleetStartServices['http']) => { + // @ts-ignore + const epmPackageResponse: GetInfoResponse = { + response: { + name: 'nginx', + title: 'Nginx', + version: '0.3.7', + release: 'experimental', + description: 'Nginx Integration', + type: 'integration', + download: '/epr/nginx/nginx-0.3.7.zip', + path: '/package/nginx/0.3.7', + icons: [ + { + src: '/img/logo_nginx.svg', + path: '/package/nginx/0.3.7/img/logo_nginx.svg', + title: 'logo nginx', + size: '32x32', + type: 'image/svg+xml', + }, + ], + format_version: '1.0.0', + readme: '/package/nginx/0.3.7/docs/README.md', + license: 'basic', + categories: ['web', 'security'], + conditions: { 'kibana.version': '^7.9.0' }, + screenshots: [ + { + src: '/img/kibana-nginx.png', + path: '/package/nginx/0.3.7/img/kibana-nginx.png', + title: 'kibana nginx', + size: '1218x1266', + type: 'image/png', + }, + { + src: '/img/metricbeat-nginx.png', + path: '/package/nginx/0.3.7/img/metricbeat-nginx.png', + title: 'metricbeat nginx', + size: '2560x2100', + type: 'image/png', + }, + ], + assets: { + kibana: { + dashboard: [ + { + pkgkey: 'nginx-0.3.7', + service: 'kibana', + type: 'dashboard' as KibanaAssetType, + file: 'nginx-023d2930-f1a5-11e7-a9ef-93c69af7b129.json', + }, + ], + search: [ + { + pkgkey: 'nginx-0.3.7', + service: 'kibana', + type: 'search' as KibanaAssetType, + file: 'nginx-6d9e66d0-a1f0-11e7-928f-5dbe6f6f5519.json', + }, + ], + visualization: [ + { + pkgkey: 'nginx-0.3.7', + service: 'kibana', + type: 'visualization' as KibanaAssetType, + file: 'nginx-0dd6f320-a29f-11e7-928f-5dbe6f6f5519.json', + }, + ], + }, + }, + policy_templates: [ + { + name: 'nginx', + title: 'Nginx logs and metrics', + description: 'Collect logs and metrics from Nginx instances', + inputs: [ + { + type: 'logfile', + title: 'Collect logs from Nginx instances', + description: 'Collecting Nginx access, error and ingress controller logs', + }, + { + type: 'nginx/metrics', + vars: [ + { + name: 'hosts', + type: 'text', + title: 'Hosts', + multi: true, + required: true, + show_user: true, + default: ['http://127.0.0.1:80'], + }, + ], + title: 'Collect metrics from Nginx instances', + description: 'Collecting Nginx stub status metrics', + }, + ], + multiple: true, + }, + ], + data_streams: [ + { + type: 'logs', + dataset: 'nginx.access', + title: 'Nginx access logs', + release: 'experimental', + ingest_pipeline: 'default', + streams: [ + { + input: 'logfile', + vars: [ + { + name: 'paths', + type: 'text', + title: 'Paths', + multi: true, + required: true, + show_user: true, + default: ['/var/log/nginx/access.log*'], + }, + ], + template_path: 'stream.yml.hbs', + title: 'Nginx access logs', + description: 'Collect Nginx access logs', + enabled: true, + }, + ], + package: 'nginx', + path: 'access', + }, + { + type: 'logs', + dataset: 'nginx.error', + title: 'Nginx error logs', + release: 'experimental', + ingest_pipeline: 'default', + streams: [ + { + input: 'logfile', + vars: [ + { + name: 'paths', + type: 'text', + title: 'Paths', + multi: true, + required: true, + show_user: true, + default: ['/var/log/nginx/error.log*'], + }, + ], + template_path: 'stream.yml.hbs', + title: 'Nginx error logs', + description: 'Collect Nginx error logs', + enabled: true, + }, + ], + package: 'nginx', + path: 'error', + }, + { + type: 'logs', + dataset: 'nginx.ingress_controller', + title: 'Nginx ingress_controller logs', + release: 'experimental', + ingest_pipeline: 'default', + streams: [ + { + input: 'logfile', + vars: [ + { + name: 'paths', + type: 'text', + title: 'Paths', + multi: true, + required: true, + show_user: true, + default: ['/var/log/nginx/ingress.log*'], + }, + ], + template_path: 'stream.yml.hbs', + title: 'Nginx ingress controller logs', + description: 'Collect Nginx ingress controller logs', + enabled: false, + }, + ], + package: 'nginx', + path: 'ingress_controller', + }, + { + type: 'metrics', + dataset: 'nginx.stubstatus', + title: 'Nginx stubstatus metrics', + release: 'experimental', + streams: [ + { + input: 'nginx/metrics', + vars: [ + { + name: 'period', + type: 'text', + title: 'Period', + multi: false, + required: true, + show_user: true, + default: '10s', + }, + { + name: 'server_status_path', + type: 'text', + title: 'Server Status Path', + multi: false, + required: true, + show_user: false, + default: '/nginx_status', + }, + ], + template_path: 'stream.yml.hbs', + title: 'Nginx stub status metrics', + description: 'Collect Nginx stub status metrics', + enabled: true, + }, + ], + package: 'nginx', + path: 'stubstatus', + }, + ], + owner: { github: 'elastic/integrations-services' }, + latestVersion: '0.3.7', + removable: true, + status: 'not_installed', + }, + } as GetInfoResponse; + + const packageReadMe = ` +# Nginx Integration + +This integration periodically fetches metrics from [Nginx](https://nginx.org/) servers. It can parse access and error +logs created by the HTTP server. + +## Compatibility + +The Nginx \`stubstatus\` metrics was tested with Nginx 1.9 and are expected to work with all version >= 1.9. +The logs were tested with version 1.10. +On Windows, the module was tested with Nginx installed from the Chocolatey repository. +`; + + const agentsSetupResponse: GetFleetStatusResponse = { isReady: true, missing_requirements: [] }; + + http.get.mockImplementation(async (path) => { + if (typeof path === 'string') { + if (path === epmRouteService.getInfoPath(`nginx-0.3.7`)) { + return epmPackageResponse; + } + + if (path === epmRouteService.getFilePath('/package/nginx/0.3.7/docs/README.md')) { + return packageReadMe; + } + + if (path === fleetSetupRouteService.getFleetSetupPath()) { + return agentsSetupResponse; + } + + const err = new Error(`API [GET ${path}] is not MOCKED!`); + // eslint-disable-next-line no-console + console.log(err); + throw err; + } + }); +}; diff --git a/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.tsx b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.tsx index aad8f9701923e..ba667200571ba 100644 --- a/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.tsx +++ b/x-pack/plugins/fleet/public/applications/fleet/sections/epm/screens/detail/index.tsx @@ -35,6 +35,7 @@ import { RELEASE_BADGE_LABEL, RELEASE_BADGE_DESCRIPTION } from '../../components import { UpdateIcon } from '../../components/icons'; import { Content } from './content'; import './index.scss'; +import { useUIExtension } from '../../../../hooks/use_ui_extension'; export const DEFAULT_PANEL: DetailViewPanelName = 'overview'; @@ -53,6 +54,9 @@ const PanelDisplayNames: Record = { settings: i18n.translate('xpack.fleet.epm.packageDetailsNav.settingsLinkText', { defaultMessage: 'Settings', }), + custom: i18n.translate('xpack.fleet.epm.packageDetailsNav.packageCustomLinkText', { + defaultMessage: 'Custom', + }), }; const Divider = styled.div` @@ -72,8 +76,7 @@ function Breadcrumbs({ packageTitle }: { packageTitle: string }) { } export function Detail() { - // TODO: fix forced cast if possible - const { pkgkey, panel = DEFAULT_PANEL } = useParams() as DetailParams; + const { pkgkey, panel = DEFAULT_PANEL } = useParams(); const { getHref } = useLink(); const hasWriteCapabilites = useCapabilities().write; @@ -91,6 +94,10 @@ export function Detail() { pkgkey ); + const packageInstallStatus = packageInfoData?.response.status; + const showCustomTab = + useUIExtension(packageInfoData?.response.name ?? '', 'package-detail-custom') !== undefined; + // Track install status state useEffect(() => { if (packageInfoData?.response) { @@ -236,22 +243,31 @@ export function Detail() { return (entries(PanelDisplayNames) .filter(([panelId]) => { - return ( - panelId !== 'policies' || packageInfoData?.response.status === InstallStatus.installed - ); + // Don't show `Policies` tab if package is not installed + if (panelId === 'policies' && packageInstallStatus !== InstallStatus.installed) { + return false; + } + + // Don't show `custom` tab if a custom component is not registered + if (panelId === 'custom' && !showCustomTab) { + return false; + } + + return true; }) .map(([panelId, display]) => { return { id: panelId, name: display, isSelected: panelId === panel, + 'data-test-subj': `tab-${panelId}`, href: getHref('integration_details', { pkgkey: `${packageInfo?.name}-${packageInfo?.version}`, panel: panelId, }), }; }) as unknown) as WithHeaderLayoutProps['tabs']; - }, [getHref, packageInfo, packageInfoData?.response?.status, panel]); + }, [getHref, packageInfo, panel, showCustomTab, packageInstallStatus]); return ( >; coreStart: AppMountContext['core']; navigation: NavigationStart; - licensing: LicensingPluginSetup; + licensing: LicensingPluginStart; chrome: ChromeStart; toastNotifications: ToastsStart; indexPatterns: IndexPatternsContract; diff --git a/x-pack/plugins/graph/public/plugin.ts b/x-pack/plugins/graph/public/plugin.ts index eb0089feaa072..b1efdeacacc3e 100644 --- a/x-pack/plugins/graph/public/plugin.ts +++ b/x-pack/plugins/graph/public/plugin.ts @@ -18,7 +18,7 @@ import { NavigationPublicPluginStart as NavigationStart } from '../../../../src/ import { DataPublicPluginStart } from '../../../../src/plugins/data/public'; import { toggleNavLink } from './services/toggle_nav_link'; -import { LicensingPluginSetup } from '../../licensing/public'; +import { LicensingPluginStart } from '../../licensing/public'; import { checkLicense } from '../common/check_license'; import { FeatureCatalogueCategory, @@ -30,12 +30,12 @@ import { ConfigSchema } from '../config'; import { SavedObjectsStart } from '../../../../src/plugins/saved_objects/public'; export interface GraphPluginSetupDependencies { - licensing: LicensingPluginSetup; home?: HomePublicPluginSetup; } export interface GraphPluginStartDependencies { navigation: NavigationStart; + licensing: LicensingPluginStart; data: DataPublicPluginStart; savedObjects: SavedObjectsStart; kibanaLegacy: KibanaLegacyStart; @@ -44,16 +44,9 @@ export interface GraphPluginStartDependencies { export class GraphPlugin implements Plugin { - private licensing: LicensingPluginSetup | null = null; - constructor(private initializerContext: PluginInitializerContext) {} - setup( - core: CoreSetup, - { licensing, home }: GraphPluginSetupDependencies - ) { - this.licensing = licensing; - + setup(core: CoreSetup, { home }: GraphPluginSetupDependencies) { if (home) { home.featureCatalogue.register({ id: 'graph', @@ -92,7 +85,7 @@ export class GraphPlugin return renderApp({ ...params, pluginInitializerContext: this.initializerContext, - licensing, + licensing: pluginsStart.licensing, core: coreStart, navigation: pluginsStart.navigation, data: pluginsStart.data, @@ -115,11 +108,8 @@ export class GraphPlugin }); } - start(core: CoreStart, { home }: GraphPluginStartDependencies) { - if (this.licensing === null) { - throw new Error('Start called before setup'); - } - this.licensing.license$.subscribe((license) => { + start(core: CoreStart, { home, licensing }: GraphPluginStartDependencies) { + licensing.license$.subscribe((license) => { const licenseInformation = checkLicense(license); toggleNavLink(licenseInformation, core.chrome.navLinks); if (home && !licenseInformation.enableAppLink) { diff --git a/x-pack/plugins/graph/server/routes/explore.ts b/x-pack/plugins/graph/server/routes/explore.ts index a1e24695413c9..762186d69d819 100644 --- a/x-pack/plugins/graph/server/routes/explore.ts +++ b/x-pack/plugins/graph/server/routes/explore.ts @@ -4,12 +4,18 @@ * you may not use this file except in compliance with the Elastic License. */ +import { errors } from '@elastic/elasticsearch'; import { IRouter } from 'kibana/server'; import { schema } from '@kbn/config-schema'; import Boom from '@hapi/boom'; -import { get } from 'lodash'; import { LicenseState, verifyApiAccess } from '../lib/license_state'; +interface ErrorResponse { + error?: { + root_cause?: Array<{ type: string; reason: string }>; + }; +} + export function registerExploreRoute({ router, licenseState, @@ -31,11 +37,7 @@ export function registerExploreRoute({ async ( { core: { - elasticsearch: { - legacy: { - client: { callAsCurrentUser: callCluster }, - }, - }, + elasticsearch: { client: esClient }, }, }, request, @@ -46,32 +48,31 @@ export function registerExploreRoute({ try { return response.ok({ body: { - resp: await callCluster('transport.request', { - path: '/' + encodeURIComponent(request.body.index) + '/_graph/explore', - body: request.body.query, - method: 'POST', - query: {}, - }), + resp: ( + await esClient.asCurrentUser.transport.request({ + path: '/' + encodeURIComponent(request.body.index) + '/_graph/explore', + body: request.body.query, + method: 'POST', + }) + ).body, }, }); } catch (error) { - // Extract known reasons for bad choice of field - const relevantCause = get( - error, - 'body.error.root_cause', - [] as Array<{ type: string; reason: string }> - ).find((cause: { type: string; reason: string }) => { - return ( - cause.reason.includes('Fielddata is disabled on text fields') || - cause.reason.includes('No support for examining floating point') || - cause.reason.includes('Sample diversifying key must be a single valued-field') || - cause.reason.includes('Failed to parse query') || - cause.type === 'parsing_exception' - ); - }); + if (error instanceof errors.ResponseError) { + const errorBody: ErrorResponse = error.body; + const relevantCause = (errorBody.error?.root_cause ?? []).find((cause) => { + return ( + cause.reason.includes('Fielddata is disabled on text fields') || + cause.reason.includes('No support for examining floating point') || + cause.reason.includes('Sample diversifying key must be a single valued-field') || + cause.reason.includes('Failed to parse query') || + cause.type === 'parsing_exception' + ); + }); - if (relevantCause) { - throw Boom.badRequest(relevantCause.reason); + if (relevantCause) { + throw Boom.badRequest(relevantCause.reason); + } } return response.internalError({ diff --git a/x-pack/plugins/graph/server/routes/search.ts b/x-pack/plugins/graph/server/routes/search.ts index e1d430eeb311a..1bd2861687281 100644 --- a/x-pack/plugins/graph/server/routes/search.ts +++ b/x-pack/plugins/graph/server/routes/search.ts @@ -31,11 +31,7 @@ export function registerSearchRoute({ { core: { uiSettings: { client: uiSettings }, - elasticsearch: { - legacy: { - client: { callAsCurrentUser: callCluster }, - }, - }, + elasticsearch: { client: esClient }, }, }, request, @@ -47,12 +43,14 @@ export function registerSearchRoute({ try { return response.ok({ body: { - resp: await callCluster('search', { - index: request.body.index, - body: request.body.body, - rest_total_hits_as_int: true, - ignore_throttled: !includeFrozen, - }), + resp: ( + await esClient.asCurrentUser.search({ + index: request.body.index, + body: request.body.body, + rest_total_hits_as_int: true, + ignore_throttled: !includeFrozen, + }) + ).body, }, }); } catch (error) { diff --git a/x-pack/plugins/lens/public/editor_frame_service/editor_frame/config_panel/layer_settings.tsx b/x-pack/plugins/lens/public/editor_frame_service/editor_frame/config_panel/layer_settings.tsx index abbd7e0838bed..bc537e5a7d689 100644 --- a/x-pack/plugins/lens/public/editor_frame_service/editor_frame/config_panel/layer_settings.tsx +++ b/x-pack/plugins/lens/public/editor_frame_service/editor_frame/config_panel/layer_settings.tsx @@ -26,10 +26,21 @@ export function LayerSettings({ return null; } - const a11yText = i18n.translate('xpack.lens.editLayerSettings', { - defaultMessage: 'Edit layer settings', - }); + const a11yText = (chartType?: string) => { + if (chartType) { + return i18n.translate('xpack.lens.editLayerSettingsChartType', { + defaultMessage: 'Edit layer settings, {chartType}', + values: { + chartType, + }, + }); + } + return i18n.translate('xpack.lens.editLayerSettings', { + defaultMessage: 'Edit layer settings', + }); + }; + const contextMenuIcon = activeVisualization.getLayerContextMenuIcon?.(layerConfigProps); return ( setIsOpen(!isOpen)} data-test-subj="lns_layer_settings" /> diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_editor.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_editor.tsx index 0a67c157bd837..62de601bb7888 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_editor.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_editor.tsx @@ -6,7 +6,7 @@ import './dimension_editor.scss'; import _ from 'lodash'; -import React, { useState, useMemo } from 'react'; +import React, { useState, useMemo, useEffect, useRef } from 'react'; import { i18n } from '@kbn/i18n'; import { EuiListGroup, @@ -34,6 +34,7 @@ import { BucketNestingEditor } from './bucket_nesting_editor'; import { IndexPattern, IndexPatternLayer } from '../types'; import { trackUiEvent } from '../../lens_ui_telemetry'; import { FormatSelector } from './format_selector'; +import { TimeScaling } from './time_scaling'; const operationPanels = getOperationDisplay(); @@ -43,10 +44,30 @@ export interface DimensionEditorProps extends IndexPatternDimensionEditorProps { currentIndexPattern: IndexPattern; } +/** + * This component shows a debounced input for the label of a dimension. It will update on root state changes + * if no debounced changes are in flight because the user is currently typing into the input. + */ const LabelInput = ({ value, onChange }: { value: string; onChange: (value: string) => void }) => { const [inputValue, setInputValue] = useState(value); + const unflushedChanges = useRef(false); + + const onChangeDebounced = useMemo(() => { + const callback = _.debounce((val: string) => { + onChange(val); + unflushedChanges.current = false; + }, 256); + return (val: string) => { + unflushedChanges.current = true; + callback(val); + }; + }, [onChange]); - const onChangeDebounced = useMemo(() => _.debounce(onChange, 256), [onChange]); + useEffect(() => { + if (!unflushedChanges.current && value !== inputValue) { + setInputValue(value); + } + }, [value, inputValue]); const handleInputChange = (e: React.ChangeEvent) => { const val = String(e.target.value); @@ -329,6 +350,17 @@ export function DimensionEditor(props: DimensionEditorProps) { ) : null} + {!currentFieldIsInvalid && !incompatibleSelectedOperationType && selectedColumn && ( + + setState(mergeLayer({ layerId, state, newLayer })) + } + /> + )} + {!currentFieldIsInvalid && !incompatibleSelectedOperationType && selectedColumn && diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_panel.test.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_panel.test.tsx index 2e57ecee86033..29a0586c92ffe 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_panel.test.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/dimension_panel.test.tsx @@ -5,7 +5,7 @@ */ import { ReactWrapper, ShallowWrapper } from 'enzyme'; -import React from 'react'; +import React, { ChangeEvent, MouseEvent } from 'react'; import { act } from 'react-dom/test-utils'; import { EuiComboBox, EuiListGroupItemProps, EuiListGroup, EuiRange } from '@elastic/eui'; import { DataPublicPluginStart } from '../../../../../../src/plugins/data/public'; @@ -22,6 +22,10 @@ import { documentField } from '../document_field'; import { OperationMetadata } from '../../types'; import { DateHistogramIndexPatternColumn } from '../operations/definitions/date_histogram'; import { getFieldByNameFactory } from '../pure_helpers'; +import { TimeScaling } from './time_scaling'; +import { EuiSelect } from '@elastic/eui'; +import { EuiButtonIcon } from '@elastic/eui'; +import { DimensionEditor } from './dimension_editor'; jest.mock('../loader'); jest.mock('../operations'); @@ -111,7 +115,10 @@ describe('IndexPatternDimensionEditorPanel', () => { let defaultProps: IndexPatternDimensionEditorProps; function getStateWithColumns(columns: Record) { - return { ...state, layers: { first: { ...state.layers.first, columns } } }; + return { + ...state, + layers: { first: { ...state.layers.first, columns, columnOrder: Object.keys(columns) } }, + }; } beforeEach(() => { @@ -785,6 +792,226 @@ describe('IndexPatternDimensionEditorPanel', () => { }); }); + describe('time scaling', () => { + function getProps(colOverrides: Partial) { + return { + ...defaultProps, + state: getStateWithColumns({ + datecolumn: { + dataType: 'date', + isBucketed: true, + label: '', + operationType: 'date_histogram', + sourceField: 'ts', + params: { + interval: '1d', + }, + }, + col2: { + dataType: 'number', + isBucketed: false, + label: 'Count of records', + operationType: 'count', + sourceField: 'Records', + ...colOverrides, + } as IndexPatternColumn, + }), + columnId: 'col2', + }; + } + it('should not show custom options if time scaling is not available', () => { + wrapper = mount( + + ); + expect(wrapper.find('[data-test-subj="indexPattern-time-scaling"]')).toHaveLength(0); + }); + + it('should show custom options if time scaling is available', () => { + wrapper = mount(); + expect( + wrapper + .find(TimeScaling) + .find('[data-test-subj="indexPattern-time-scaling-popover"]') + .exists() + ).toBe(true); + }); + + it('should show current time scaling if set', () => { + wrapper = mount(); + expect( + wrapper + .find('[data-test-subj="indexPattern-time-scaling-unit"]') + .find(EuiSelect) + .prop('value') + ).toEqual('d'); + }); + + it('should allow to set time scaling initially', () => { + const props = getProps({}); + wrapper = shallow(); + wrapper + .find(DimensionEditor) + .dive() + .find(TimeScaling) + .dive() + .find('[data-test-subj="indexPattern-time-scaling-enable"]') + .prop('onClick')!({} as MouseEvent); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: 's', + label: 'Count of records per second', + }), + }, + }, + }, + }); + }); + + it('should carry over time scaling to other operation if possible', () => { + const props = getProps({ + timeScale: 'h', + sourceField: 'bytes', + operationType: 'sum', + label: 'Sum of bytes per hour', + }); + wrapper = mount(); + wrapper + .find('button[data-test-subj="lns-indexPatternDimension-count incompatible"]') + .simulate('click'); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: 'h', + label: 'Count of records per hour', + }), + }, + }, + }, + }); + }); + + it('should not carry over time scaling if the other operation does not support it', () => { + const props = getProps({ + timeScale: 'h', + sourceField: 'bytes', + operationType: 'sum', + label: 'Sum of bytes per hour', + }); + wrapper = mount(); + wrapper.find('button[data-test-subj="lns-indexPatternDimension-avg"]').simulate('click'); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: undefined, + label: 'Average of bytes', + }), + }, + }, + }, + }); + }); + + it('should allow to change time scaling', () => { + const props = getProps({ timeScale: 's', label: 'Count of records per second' }); + wrapper = mount(); + wrapper + .find('[data-test-subj="indexPattern-time-scaling-unit"]') + .find(EuiSelect) + .prop('onChange')!(({ + target: { value: 'h' }, + } as unknown) as ChangeEvent); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: 'h', + label: 'Count of records per hour', + }), + }, + }, + }, + }); + }); + + it('should not adjust label if it is custom', () => { + const props = getProps({ timeScale: 's', customLabel: true, label: 'My label' }); + wrapper = mount(); + wrapper + .find('[data-test-subj="indexPattern-time-scaling-unit"]') + .find(EuiSelect) + .prop('onChange')!(({ + target: { value: 'h' }, + } as unknown) as ChangeEvent); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: 'h', + label: 'My label', + }), + }, + }, + }, + }); + }); + + it('should allow to remove time scaling', () => { + const props = getProps({ timeScale: 's', label: 'Count of records per second' }); + wrapper = mount(); + wrapper + .find('[data-test-subj="indexPattern-time-scaling-remove"]') + .find(EuiButtonIcon) + .prop('onClick')!( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + {} as any + ); + expect(props.setState).toHaveBeenCalledWith({ + ...props.state, + layers: { + first: { + ...props.state.layers.first, + columns: { + ...props.state.layers.first.columns, + col2: expect.objectContaining({ + timeScale: undefined, + label: 'Count of records', + }), + }, + }, + }, + }); + }); + }); + it('should render invalid field if field reference is broken', () => { wrapper = mount( { act(() => { wrapper.find('[data-test-subj="lns-indexPatternDimension-min"]').first().prop('onClick')!( - {} as React.MouseEvent<{}, MouseEvent> + {} as MouseEvent ); }); diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/time_scaling.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/time_scaling.tsx new file mode 100644 index 0000000000000..d5a90f7275279 --- /dev/null +++ b/x-pack/plugins/lens/public/indexpattern_datasource/dimension_panel/time_scaling.tsx @@ -0,0 +1,177 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { EuiToolTip } from '@elastic/eui'; +import { EuiIcon } from '@elastic/eui'; +import { + EuiLink, + EuiFormRow, + EuiSelect, + EuiFlexItem, + EuiFlexGroup, + EuiButtonIcon, + EuiText, + EuiPopover, + EuiButtonEmpty, + EuiSpacer, +} from '@elastic/eui'; +import { i18n } from '@kbn/i18n'; +import React, { useState } from 'react'; +import { + adjustTimeScaleLabelSuffix, + DEFAULT_TIME_SCALE, + IndexPatternColumn, + operationDefinitionMap, +} from '../operations'; +import { unitSuffixesLong } from '../suffix_formatter'; +import { TimeScaleUnit } from '../time_scale'; +import { IndexPatternLayer } from '../types'; + +export function setTimeScaling( + columnId: string, + layer: IndexPatternLayer, + timeScale: TimeScaleUnit | undefined +) { + const currentColumn = layer.columns[columnId]; + const label = currentColumn.customLabel + ? currentColumn.label + : adjustTimeScaleLabelSuffix(currentColumn.label, currentColumn.timeScale, timeScale); + return { + ...layer, + columns: { + ...layer.columns, + [columnId]: { + ...layer.columns[columnId], + label, + timeScale, + }, + }, + }; +} + +export function TimeScaling({ + selectedColumn, + columnId, + layer, + updateLayer, +}: { + selectedColumn: IndexPatternColumn; + columnId: string; + layer: IndexPatternLayer; + updateLayer: (newLayer: IndexPatternLayer) => void; +}) { + const [popoverOpen, setPopoverOpen] = useState(false); + const hasDateHistogram = layer.columnOrder.some( + (colId) => layer.columns[colId].operationType === 'date_histogram' + ); + const selectedOperation = operationDefinitionMap[selectedColumn.operationType]; + if ( + !selectedOperation.timeScalingMode || + selectedOperation.timeScalingMode === 'disabled' || + !hasDateHistogram + ) { + return null; + } + + if (!selectedColumn.timeScale) { + return ( + + + { + setPopoverOpen(true); + }} + > + {i18n.translate('xpack.lens.indexPattern.timeScale.advancedSettings', { + defaultMessage: 'Add advanced options', + })} + + } + isOpen={popoverOpen} + closePopover={() => { + setPopoverOpen(false); + }} + > + + { + setPopoverOpen(false); + updateLayer(setTimeScaling(columnId, layer, DEFAULT_TIME_SCALE)); + }} + > + {i18n.translate('xpack.lens.indexPattern.timeScale.enableTimeScale', { + defaultMessage: 'Normalize by unit', + })} + + + + + ); + } + + return ( + + + {i18n.translate('xpack.lens.indexPattern.timeScale.label', { + defaultMessage: 'Normalize by unit', + })}{' '} + + + + } + > + + + ({ + value: unit, + text, + }))} + data-test-subj="indexPattern-time-scaling-unit" + value={selectedColumn.timeScale} + onChange={(e) => { + updateLayer(setTimeScaling(columnId, layer, e.target.value as TimeScaleUnit)); + }} + /> + + {selectedOperation.timeScalingMode === 'optional' && ( + + { + updateLayer(setTimeScaling(columnId, layer, undefined)); + }} + iconType="cross" + /> + + )} + + + ); +} diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/indexpattern.test.ts b/x-pack/plugins/lens/public/indexpattern_datasource/indexpattern.test.ts index c3247b251d88a..5153a74409bee 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/indexpattern.test.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/indexpattern.test.ts @@ -407,6 +407,86 @@ describe('IndexPattern Data Source', () => { expect(ast.chain[0].arguments.timeFields).toEqual(['timestamp', 'another_datefield']); }); + it('should add time_scale and format function if time scale is set and supported', async () => { + const queryBaseState: IndexPatternBaseState = { + currentIndexPatternId: '1', + layers: { + first: { + indexPatternId: '1', + columnOrder: ['col1', 'col2', 'col3'], + columns: { + col1: { + label: 'Count of records', + dataType: 'number', + isBucketed: false, + sourceField: 'Records', + operationType: 'count', + timeScale: 'h', + }, + col2: { + label: 'Average of bytes', + dataType: 'number', + isBucketed: false, + sourceField: 'bytes', + operationType: 'avg', + timeScale: 'h', + }, + col3: { + label: 'Date', + dataType: 'date', + isBucketed: true, + operationType: 'date_histogram', + sourceField: 'timestamp', + params: { + interval: 'auto', + }, + }, + }, + }, + }, + }; + + const state = enrichBaseState(queryBaseState); + + const ast = indexPatternDatasource.toExpression(state, 'first') as Ast; + const timeScaleCalls = ast.chain.filter((fn) => fn.function === 'lens_time_scale'); + const formatCalls = ast.chain.filter((fn) => fn.function === 'lens_format_column'); + expect(timeScaleCalls).toHaveLength(1); + expect(timeScaleCalls[0].arguments).toMatchInlineSnapshot(` + Object { + "dateColumnId": Array [ + "col3", + ], + "inputColumnId": Array [ + "col1", + ], + "outputColumnId": Array [ + "col1", + ], + "targetUnit": Array [ + "h", + ], + } + `); + expect(formatCalls[0]).toMatchInlineSnapshot(` + Object { + "arguments": Object { + "columnId": Array [ + "col1", + ], + "format": Array [ + "", + ], + "parentFormat": Array [ + "{\\"id\\":\\"suffix\\",\\"params\\":{\\"unit\\":\\"h\\"}}", + ], + }, + "function": "lens_format_column", + "type": "function", + } + `); + }); + it('should rename the output from esaggs when using flat query', () => { const queryBaseState: IndexPatternBaseState = { currentIndexPatternId: '1', diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/__mocks__/index.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/__mocks__/index.ts index f27fb8d4642f6..385f2ab941ef2 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/__mocks__/index.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/__mocks__/index.ts @@ -6,6 +6,7 @@ const actualOperations = jest.requireActual('../operations'); const actualHelpers = jest.requireActual('../layer_helpers'); +const actualTimeScaleUtils = jest.requireActual('../time_scale_utils'); const actualMocks = jest.requireActual('../mocks'); jest.spyOn(actualOperations.operationDefinitionMap.date_histogram, 'paramEditor'); @@ -41,4 +42,6 @@ export const { isReferenced, } = actualHelpers; +export const { adjustTimeScaleLabelSuffix, DEFAULT_TIME_SCALE } = actualTimeScaleUtils; + export const { createMockedReferenceOperation } = actualMocks; diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions.test.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions.test.ts new file mode 100644 index 0000000000000..18aa15badec4f --- /dev/null +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions.test.ts @@ -0,0 +1,215 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { + sumOperation, + averageOperation, + countOperation, + counterRateOperation, + movingAverageOperation, + derivativeOperation, +} from './definitions'; +import { getFieldByNameFactory } from '../pure_helpers'; +import { documentField } from '../document_field'; +import { IndexPattern, IndexPatternLayer, IndexPatternField } from '../types'; +import { IndexPatternColumn } from '.'; + +const indexPatternFields = [ + { + name: 'timestamp', + displayName: 'timestampLabel', + type: 'date', + aggregatable: true, + searchable: true, + }, + { + name: 'start_date', + displayName: 'start_date', + type: 'date', + aggregatable: true, + searchable: true, + }, + { + name: 'bytes', + displayName: 'bytes', + type: 'number', + aggregatable: true, + searchable: true, + }, + { + name: 'memory', + displayName: 'memory', + type: 'number', + aggregatable: true, + searchable: true, + }, + { + name: 'source', + displayName: 'source', + type: 'string', + aggregatable: true, + searchable: true, + }, + { + name: 'dest', + displayName: 'dest', + type: 'string', + aggregatable: true, + searchable: true, + }, + documentField, +]; + +const indexPattern = { + id: '1', + title: 'my-fake-index-pattern', + timeFieldName: 'timestamp', + hasRestrictions: false, + fields: indexPatternFields, + getFieldByName: getFieldByNameFactory([...indexPatternFields]), +}; + +const baseColumnArgs: { + previousColumn: IndexPatternColumn; + indexPattern: IndexPattern; + layer: IndexPatternLayer; + field: IndexPatternField; +} = { + previousColumn: { + label: 'Count of records per hour', + timeScale: 'h', + dataType: 'number', + isBucketed: false, + + // Private + operationType: 'count', + sourceField: 'Records', + }, + indexPattern, + layer: { + columns: {}, + columnOrder: [], + indexPatternId: '1', + }, + field: indexPattern.fields[2], +}; + +describe('time scale transition', () => { + it('should carry over time scale and adjust label on operation from count to sum', () => { + expect( + sumOperation.buildColumn({ + ...baseColumnArgs, + }) + ).toEqual( + expect.objectContaining({ + timeScale: 'h', + label: 'Sum of bytes per hour', + }) + ); + }); + + it('should carry over time scale and adjust label on operation from count to calculation', () => { + [counterRateOperation, movingAverageOperation, derivativeOperation].forEach( + (calculationOperation) => { + const result = calculationOperation.buildColumn({ + ...baseColumnArgs, + referenceIds: [], + }); + expect(result.timeScale).toEqual('h'); + expect(result.label).toContain('per hour'); + } + ); + }); + + it('should carry over time scale and adjust label on operation from sum to count', () => { + expect( + countOperation.buildColumn({ + ...baseColumnArgs, + previousColumn: { + label: 'Sum of bytes per hour', + timeScale: 'h', + dataType: 'number', + isBucketed: false, + operationType: 'sum', + sourceField: 'bytes', + }, + }) + ).toEqual( + expect.objectContaining({ + timeScale: 'h', + label: 'Count of records per hour', + }) + ); + }); + + it('should not set time scale if it was not set previously', () => { + expect( + countOperation.buildColumn({ + ...baseColumnArgs, + previousColumn: { + label: 'Sum of bytes', + dataType: 'number', + isBucketed: false, + operationType: 'sum', + sourceField: 'bytes', + }, + }) + ).toEqual( + expect.objectContaining({ + timeScale: undefined, + label: 'Count of records', + }) + ); + }); + + it('should set time scale to default for counter rate', () => { + expect( + counterRateOperation.buildColumn({ + indexPattern, + layer: { + columns: {}, + columnOrder: [], + indexPatternId: '1', + }, + referenceIds: [], + }) + ).toEqual( + expect.objectContaining({ + timeScale: 's', + }) + ); + }); + + it('should adjust label on field change', () => { + expect( + sumOperation.onFieldChange( + { + label: 'Sum of bytes per hour', + timeScale: 'h', + dataType: 'number', + isBucketed: false, + + // Private + operationType: 'sum', + sourceField: 'bytes', + }, + indexPattern.fields[3] + ) + ).toEqual( + expect.objectContaining({ + timeScale: 'h', + label: 'Sum of memory per hour', + }) + ); + }); + + it('should not carry over time scale if target does not support time scaling', () => { + const result = averageOperation.buildColumn({ + ...baseColumnArgs, + }); + expect(result.timeScale).toBeUndefined(); + }); +}); diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/counter_rate.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/counter_rate.tsx index d256b74696a4c..0cfba4cfc739f 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/counter_rate.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/counter_rate.tsx @@ -7,10 +7,16 @@ import { i18n } from '@kbn/i18n'; import { FormattedIndexPatternColumn, ReferenceBasedIndexPatternColumn } from '../column_types'; import { IndexPatternLayer } from '../../../types'; -import { checkForDateHistogram, dateBasedOperationToExpression, hasDateField } from './utils'; +import { + buildLabelFunction, + checkForDateHistogram, + dateBasedOperationToExpression, + hasDateField, +} from './utils'; +import { DEFAULT_TIME_SCALE } from '../../time_scale_utils'; import { OperationDefinition } from '..'; -const ofName = (name?: string) => { +const ofName = buildLabelFunction((name?: string) => { return i18n.translate('xpack.lens.indexPattern.CounterRateOf', { defaultMessage: 'Counter rate of {name}', values: { @@ -21,7 +27,7 @@ const ofName = (name?: string) => { }), }, }); -}; +}); export type CounterRateIndexPatternColumn = FormattedIndexPatternColumn & ReferenceBasedIndexPatternColumn & { @@ -54,20 +60,22 @@ export const counterRateOperation: OperationDefinition< }; }, getDefaultLabel: (column, indexPattern, columns) => { - return ofName(columns[column.references[0]]?.label); + return ofName(columns[column.references[0]]?.label, column.timeScale); }, toExpression: (layer, columnId) => { return dateBasedOperationToExpression(layer, columnId, 'lens_counter_rate'); }, buildColumn: ({ referenceIds, previousColumn, layer }) => { const metric = layer.columns[referenceIds[0]]; + const timeScale = previousColumn?.timeScale || DEFAULT_TIME_SCALE; return { - label: ofName(metric?.label), + label: ofName(metric?.label, timeScale), dataType: 'number', operationType: 'counter_rate', isBucketed: false, scale: 'ratio', references: referenceIds, + timeScale, params: previousColumn?.dataType === 'number' && previousColumn.params && @@ -88,4 +96,5 @@ export const counterRateOperation: OperationDefinition< }) ); }, + timeScalingMode: 'mandatory', }; diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/derivative.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/derivative.tsx index 7398f7e07ea4e..41fe361c7ba9c 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/derivative.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/derivative.tsx @@ -7,10 +7,16 @@ import { i18n } from '@kbn/i18n'; import { FormattedIndexPatternColumn, ReferenceBasedIndexPatternColumn } from '../column_types'; import { IndexPatternLayer } from '../../../types'; -import { checkForDateHistogram, dateBasedOperationToExpression, hasDateField } from './utils'; +import { + buildLabelFunction, + checkForDateHistogram, + dateBasedOperationToExpression, + hasDateField, +} from './utils'; +import { adjustTimeScaleOnOtherColumnChange } from '../../time_scale_utils'; import { OperationDefinition } from '..'; -const ofName = (name?: string) => { +const ofName = buildLabelFunction((name?: string) => { return i18n.translate('xpack.lens.indexPattern.derivativeOf', { defaultMessage: 'Differences of {name}', values: { @@ -21,7 +27,7 @@ const ofName = (name?: string) => { }), }, }); -}; +}); export type DerivativeIndexPatternColumn = FormattedIndexPatternColumn & ReferenceBasedIndexPatternColumn & { @@ -53,7 +59,7 @@ export const derivativeOperation: OperationDefinition< }; }, getDefaultLabel: (column, indexPattern, columns) => { - return ofName(columns[column.references[0]]?.label); + return ofName(columns[column.references[0]]?.label, column.timeScale); }, toExpression: (layer, columnId) => { return dateBasedOperationToExpression(layer, columnId, 'derivative'); @@ -61,12 +67,13 @@ export const derivativeOperation: OperationDefinition< buildColumn: ({ referenceIds, previousColumn, layer }) => { const metric = layer.columns[referenceIds[0]]; return { - label: ofName(metric?.label), + label: ofName(metric?.label, previousColumn?.timeScale), dataType: 'number', operationType: 'derivative', isBucketed: false, scale: 'ratio', references: referenceIds, + timeScale: previousColumn?.timeScale, params: previousColumn?.dataType === 'number' && previousColumn.params && @@ -79,6 +86,7 @@ export const derivativeOperation: OperationDefinition< isTransferable: (column, newIndexPattern) => { return hasDateField(newIndexPattern); }, + onOtherColumnChanged: adjustTimeScaleOnOtherColumnChange, getErrorMessage: (layer: IndexPatternLayer) => { return checkForDateHistogram( layer, @@ -87,4 +95,5 @@ export const derivativeOperation: OperationDefinition< }) ); }, + timeScalingMode: 'optional', }; diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/moving_average.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/moving_average.tsx index 795281d0fd994..522899662fbd1 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/moving_average.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/moving_average.tsx @@ -11,12 +11,18 @@ import { EuiFormRow } from '@elastic/eui'; import { EuiFieldNumber } from '@elastic/eui'; import { FormattedIndexPatternColumn, ReferenceBasedIndexPatternColumn } from '../column_types'; import { IndexPatternLayer } from '../../../types'; -import { checkForDateHistogram, dateBasedOperationToExpression, hasDateField } from './utils'; +import { + buildLabelFunction, + checkForDateHistogram, + dateBasedOperationToExpression, + hasDateField, +} from './utils'; import { updateColumnParam } from '../../layer_helpers'; import { useDebounceWithOptions } from '../helpers'; +import { adjustTimeScaleOnOtherColumnChange } from '../../time_scale_utils'; import type { OperationDefinition, ParamEditorProps } from '..'; -const ofName = (name?: string) => { +const ofName = buildLabelFunction((name?: string) => { return i18n.translate('xpack.lens.indexPattern.movingAverageOf', { defaultMessage: 'Moving average of {name}', values: { @@ -27,7 +33,7 @@ const ofName = (name?: string) => { }), }, }); -}; +}); export type MovingAverageIndexPatternColumn = FormattedIndexPatternColumn & ReferenceBasedIndexPatternColumn & { @@ -62,7 +68,7 @@ export const movingAverageOperation: OperationDefinition< }; }, getDefaultLabel: (column, indexPattern, columns) => { - return ofName(columns[column.references[0]]?.label); + return ofName(columns[column.references[0]]?.label, column.timeScale); }, toExpression: (layer, columnId) => { return dateBasedOperationToExpression(layer, columnId, 'moving_average', { @@ -72,12 +78,13 @@ export const movingAverageOperation: OperationDefinition< buildColumn: ({ referenceIds, previousColumn, layer }) => { const metric = layer.columns[referenceIds[0]]; return { - label: ofName(metric?.label), + label: ofName(metric?.label, previousColumn?.timeScale), dataType: 'number', operationType: 'moving_average', isBucketed: false, scale: 'ratio', references: referenceIds, + timeScale: previousColumn?.timeScale, params: previousColumn?.dataType === 'number' && previousColumn.params && @@ -91,6 +98,7 @@ export const movingAverageOperation: OperationDefinition< isTransferable: (column, newIndexPattern) => { return hasDateField(newIndexPattern); }, + onOtherColumnChanged: adjustTimeScaleOnOtherColumnChange, getErrorMessage: (layer: IndexPatternLayer) => { return checkForDateHistogram( layer, @@ -99,6 +107,7 @@ export const movingAverageOperation: OperationDefinition< }) ); }, + timeScalingMode: 'optional', }; function MovingAverageParamEditor({ diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/utils.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/utils.ts index c64a292280603..bac45f683e444 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/utils.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/calculations/utils.ts @@ -6,9 +6,19 @@ import { i18n } from '@kbn/i18n'; import { ExpressionFunctionAST } from '@kbn/interpreter/common'; +import { TimeScaleUnit } from '../../../time_scale'; import { IndexPattern, IndexPatternLayer } from '../../../types'; +import { adjustTimeScaleLabelSuffix } from '../../time_scale_utils'; import { ReferenceBasedIndexPatternColumn } from '../column_types'; +export const buildLabelFunction = (ofName: (name?: string) => string) => ( + name?: string, + timeScale?: TimeScaleUnit +) => { + const rawLabel = ofName(name); + return adjustTimeScaleLabelSuffix(rawLabel, undefined, timeScale); +}; + /** * Checks whether the current layer includes a date histogram and returns an error otherwise */ diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/column_types.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/column_types.ts index aef9bb7731d4c..d0a0fb4b28588 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/column_types.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/column_types.ts @@ -5,11 +5,13 @@ */ import type { Operation } from '../../../types'; +import { TimeScaleUnit } from '../../time_scale'; export interface BaseIndexPatternColumn extends Operation { // Private operationType: string; customLabel?: boolean; + timeScale?: TimeScaleUnit; } // Formatting can optionally be added to any column diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/count.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/count.tsx index 30f64929fc1af..8cb95de72f97e 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/count.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/count.tsx @@ -8,6 +8,10 @@ import { i18n } from '@kbn/i18n'; import { OperationDefinition } from './index'; import { FormattedIndexPatternColumn, FieldBasedIndexPatternColumn } from './column_types'; import { IndexPatternField } from '../../types'; +import { + adjustTimeScaleLabelSuffix, + adjustTimeScaleOnOtherColumnChange, +} from '../time_scale_utils'; const countLabel = i18n.translate('xpack.lens.indexPattern.countOf', { defaultMessage: 'Count of records', @@ -28,7 +32,7 @@ export const countOperation: OperationDefinition { return { ...oldColumn, - label: field.displayName, + label: adjustTimeScaleLabelSuffix(field.displayName, undefined, oldColumn.timeScale), sourceField: field.name, }; }, @@ -41,15 +45,16 @@ export const countOperation: OperationDefinition countLabel, + getDefaultLabel: (column) => adjustTimeScaleLabelSuffix(countLabel, undefined, column.timeScale), buildColumn({ field, previousColumn }) { return { - label: countLabel, + label: adjustTimeScaleLabelSuffix(countLabel, undefined, previousColumn?.timeScale), dataType: 'number', operationType: 'count', isBucketed: false, scale: 'ratio', sourceField: field.name, + timeScale: previousColumn?.timeScale, params: previousColumn?.dataType === 'number' && previousColumn.params && @@ -59,6 +64,7 @@ export const countOperation: OperationDefinition ({ id: columnId, enabled: true, @@ -69,4 +75,5 @@ export const countOperation: OperationDefinition { return true; }, + timeScalingMode: 'optional', }; diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/index.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/index.ts index 392377234d76d..31bb332f791da 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/index.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/index.ts @@ -99,6 +99,12 @@ export { filtersOperation } from './filters'; export { dateHistogramOperation } from './date_histogram'; export { minOperation, averageOperation, sumOperation, maxOperation } from './metrics'; export { countOperation } from './count'; +export { + cumulativeSumOperation, + counterRateOperation, + derivativeOperation, + movingAverageOperation, +} from './calculations'; /** * Properties passed to the operation-specific part of the popover editor @@ -117,6 +123,8 @@ export interface ParamEditorProps { data: DataPublicPluginStart; } +export type TimeScalingMode = 'disabled' | 'mandatory' | 'optional'; + interface BaseOperationDefinitionProps { type: C['operationType']; /** @@ -164,6 +172,13 @@ interface BaseOperationDefinitionProps { * present on the new index pattern. */ transfer?: (column: C, newIndexPattern: IndexPattern) => C; + /** + * Flag whether this operation can be scaled by time unit if a date histogram is available. + * If set to mandatory or optional, a UI element is shown in the config flyout to configure the time unit + * to scale by. The chosen unit will be persisted as `timeScale` property of the column. + * If set to optional, time scaling won't be enabled by default and can be removed. + */ + timeScalingMode?: TimeScalingMode; } interface BaseBuildColumnArgs { diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/metrics.tsx b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/metrics.tsx index 96df72ba8b7c1..45ba721981ed5 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/metrics.tsx +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/definitions/metrics.tsx @@ -6,7 +6,15 @@ import { i18n } from '@kbn/i18n'; import { OperationDefinition } from './index'; -import { FormattedIndexPatternColumn, FieldBasedIndexPatternColumn } from './column_types'; +import { + FormattedIndexPatternColumn, + FieldBasedIndexPatternColumn, + BaseIndexPatternColumn, +} from './column_types'; +import { + adjustTimeScaleLabelSuffix, + adjustTimeScaleOnOtherColumnChange, +} from '../time_scale_utils'; type MetricColumn = FormattedIndexPatternColumn & FieldBasedIndexPatternColumn & { @@ -18,17 +26,28 @@ function buildMetricOperation>({ displayName, ofName, priority, + optionalTimeScaling, }: { type: T['operationType']; displayName: string; ofName: (name: string) => string; priority?: number; + optionalTimeScaling?: boolean; }) { + const labelLookup = (name: string, column?: BaseIndexPatternColumn) => { + const rawLabel = ofName(name); + if (!optionalTimeScaling) { + return rawLabel; + } + return adjustTimeScaleLabelSuffix(rawLabel, undefined, column?.timeScale); + }; + return { type, priority, displayName, input: 'field', + timeScalingMode: optionalTimeScaling ? 'optional' : undefined, getPossibleOperationForField: ({ aggregationRestrictions, aggregatable, type: fieldType }) => { if ( fieldType === 'number' && @@ -52,22 +71,25 @@ function buildMetricOperation>({ (!newField.aggregationRestrictions || newField.aggregationRestrictions![type]) ); }, + onOtherColumnChanged: (column, otherColumns) => + optionalTimeScaling ? adjustTimeScaleOnOtherColumnChange(column, otherColumns) : column, getDefaultLabel: (column, indexPattern, columns) => - ofName(indexPattern.getFieldByName(column.sourceField)!.displayName), + labelLookup(indexPattern.getFieldByName(column.sourceField)!.displayName, column), buildColumn: ({ field, previousColumn }) => ({ - label: ofName(field.displayName), + label: labelLookup(field.displayName, previousColumn), dataType: 'number', operationType: type, sourceField: field.name, isBucketed: false, scale: 'ratio', + timeScale: optionalTimeScaling ? previousColumn?.timeScale : undefined, params: previousColumn && previousColumn.dataType === 'number' ? previousColumn.params : undefined, }), onFieldChange: (oldColumn, field) => { return { ...oldColumn, - label: ofName(field.displayName), + label: labelLookup(field.displayName, oldColumn), sourceField: field.name, }; }, @@ -138,6 +160,7 @@ export const sumOperation = buildMetricOperation({ defaultMessage: 'Sum of {name}', values: { name }, }), + optionalTimeScaling: true, }); export const medianOperation = buildMetricOperation({ diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/index.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/index.ts index 3ad9a1e5b3674..7123becf71b4d 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/index.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/index.ts @@ -6,6 +6,7 @@ export * from './operations'; export * from './layer_helpers'; +export * from './time_scale_utils'; export { OperationType, IndexPatternColumn, diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/layer_helpers.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/layer_helpers.ts index 58a066c81a1a7..260ed180da921 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/operations/layer_helpers.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/layer_helpers.ts @@ -22,6 +22,7 @@ import type { import { getSortScoreByPriority } from './operations'; import { mergeLayer } from '../state_helpers'; import { generateId } from '../../id_generator'; +import { ReferenceBasedIndexPatternColumn } from './definitions/column_types'; interface ColumnChange { op: OperationType; @@ -208,8 +209,7 @@ export function replaceColumn({ let tempLayer = { ...layer }; if (previousDefinition.input === 'fullReference') { - // @ts-expect-error references are not statically analyzed - previousColumn.references.forEach((id: string) => { + (previousColumn as ReferenceBasedIndexPatternColumn).references.forEach((id: string) => { tempLayer = deleteColumn({ layer: tempLayer, columnId: id }); }); } @@ -237,11 +237,8 @@ export function replaceColumn({ } if (operationDefinition.input === 'none') { - const newColumn = operationDefinition.buildColumn({ ...baseOptions, layer: tempLayer }); - if (previousColumn.customLabel) { - newColumn.customLabel = true; - newColumn.label = previousColumn.label; - } + let newColumn = operationDefinition.buildColumn({ ...baseOptions, layer: tempLayer }); + newColumn = adjustLabel(newColumn, previousColumn); const newColumns = { ...tempLayer.columns, [columnId]: newColumn }; return { @@ -255,12 +252,8 @@ export function replaceColumn({ throw new Error(`Invariant error: ${operationDefinition.type} operation requires field`); } - const newColumn = operationDefinition.buildColumn({ ...baseOptions, layer: tempLayer, field }); - - if (previousColumn.customLabel) { - newColumn.customLabel = true; - newColumn.label = previousColumn.label; - } + let newColumn = operationDefinition.buildColumn({ ...baseOptions, layer: tempLayer, field }); + newColumn = adjustLabel(newColumn, previousColumn); const newColumns = { ...tempLayer.columns, [columnId]: newColumn }; return { @@ -277,12 +270,7 @@ export function replaceColumn({ // Same operation, new field const newColumn = operationDefinition.onFieldChange(previousColumn, field); - if (previousColumn.customLabel) { - newColumn.customLabel = true; - newColumn.label = previousColumn.label; - } - - const newColumns = { ...layer.columns, [columnId]: newColumn }; + const newColumns = { ...layer.columns, [columnId]: adjustLabel(newColumn, previousColumn) }; return { ...layer, columnOrder: getColumnOrder({ ...layer, columns: newColumns }), @@ -293,6 +281,16 @@ export function replaceColumn({ } } +function adjustLabel(newColumn: IndexPatternColumn, previousColumn: IndexPatternColumn) { + const adjustedColumn = { ...newColumn }; + if (previousColumn.customLabel) { + adjustedColumn.customLabel = true; + adjustedColumn.label = previousColumn.label; + } + + return adjustedColumn; +} + function addBucket( layer: IndexPatternLayer, column: IndexPatternColumn, diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.test.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.test.ts new file mode 100644 index 0000000000000..841011c588433 --- /dev/null +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.test.ts @@ -0,0 +1,92 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { TimeScaleUnit } from '../time_scale'; +import { IndexPatternColumn } from './definitions'; +import { adjustTimeScaleLabelSuffix, adjustTimeScaleOnOtherColumnChange } from './time_scale_utils'; + +export const DEFAULT_TIME_SCALE = 's' as TimeScaleUnit; + +describe('time scale utils', () => { + describe('adjustTimeScaleLabelSuffix', () => { + it('should should remove existing suffix', () => { + expect(adjustTimeScaleLabelSuffix('abc per second', 's', undefined)).toEqual('abc'); + expect(adjustTimeScaleLabelSuffix('abc per hour', 'h', undefined)).toEqual('abc'); + }); + + it('should add suffix', () => { + expect(adjustTimeScaleLabelSuffix('abc', undefined, 's')).toEqual('abc per second'); + expect(adjustTimeScaleLabelSuffix('abc', undefined, 'd')).toEqual('abc per day'); + }); + + it('should change suffix', () => { + expect(adjustTimeScaleLabelSuffix('abc per second', 's', 'd')).toEqual('abc per day'); + expect(adjustTimeScaleLabelSuffix('abc per day', 'd', 's')).toEqual('abc per second'); + }); + + it('should keep current state', () => { + expect(adjustTimeScaleLabelSuffix('abc', undefined, undefined)).toEqual('abc'); + expect(adjustTimeScaleLabelSuffix('abc per day', 'd', 'd')).toEqual('abc per day'); + }); + + it('should not fail on inconsistent input', () => { + expect(adjustTimeScaleLabelSuffix('abc', 's', undefined)).toEqual('abc'); + expect(adjustTimeScaleLabelSuffix('abc', 's', 'd')).toEqual('abc per day'); + expect(adjustTimeScaleLabelSuffix('abc per day', 's', undefined)).toEqual('abc per day'); + }); + }); + + describe('adjustTimeScaleOnOtherColumnChange', () => { + const baseColumn: IndexPatternColumn = { + operationType: 'count', + sourceField: 'Records', + label: 'Count of records per second', + dataType: 'number', + isBucketed: false, + timeScale: 's', + }; + it('should keep column if there is no time scale', () => { + const column = { ...baseColumn, timeScale: undefined }; + expect(adjustTimeScaleOnOtherColumnChange(column, { col1: column })).toBe(column); + }); + + it('should keep time scale if there is a date histogram', () => { + expect( + adjustTimeScaleOnOtherColumnChange(baseColumn, { + col1: baseColumn, + col2: { + operationType: 'date_histogram', + dataType: 'date', + isBucketed: true, + label: '', + }, + }) + ).toBe(baseColumn); + }); + + it('should remove time scale if there is no date histogram', () => { + expect(adjustTimeScaleOnOtherColumnChange(baseColumn, { col1: baseColumn })).toHaveProperty( + 'timeScale', + undefined + ); + }); + + it('should remove suffix from label', () => { + expect(adjustTimeScaleOnOtherColumnChange(baseColumn, { col1: baseColumn })).toHaveProperty( + 'label', + 'Count of records' + ); + }); + + it('should keep custom label', () => { + const column = { ...baseColumn, label: 'abc', customLabel: true }; + expect(adjustTimeScaleOnOtherColumnChange(column, { col1: column })).toHaveProperty( + 'label', + 'abc' + ); + }); + }); +}); diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.ts b/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.ts new file mode 100644 index 0000000000000..5d525e573a617 --- /dev/null +++ b/x-pack/plugins/lens/public/indexpattern_datasource/operations/time_scale_utils.ts @@ -0,0 +1,54 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { unitSuffixesLong } from '../suffix_formatter'; +import { TimeScaleUnit } from '../time_scale'; +import { BaseIndexPatternColumn } from './definitions/column_types'; + +export const DEFAULT_TIME_SCALE = 's' as TimeScaleUnit; + +export function adjustTimeScaleLabelSuffix( + oldLabel: string, + previousTimeScale: TimeScaleUnit | undefined, + newTimeScale: TimeScaleUnit | undefined +) { + let cleanedLabel = oldLabel; + // remove added suffix if column had a time scale previously + if (previousTimeScale) { + const suffixPosition = oldLabel.lastIndexOf(` ${unitSuffixesLong[previousTimeScale]}`); + if (suffixPosition !== -1) { + cleanedLabel = oldLabel.substring(0, suffixPosition); + } + } + if (!newTimeScale) { + return cleanedLabel; + } + // add new suffix if column has a time scale now + return `${cleanedLabel} ${unitSuffixesLong[newTimeScale]}`; +} + +export function adjustTimeScaleOnOtherColumnChange( + column: T, + columns: Partial> +) { + if (!column.timeScale) { + return column; + } + const hasDateHistogram = Object.values(columns).some( + (col) => col?.operationType === 'date_histogram' + ); + if (hasDateHistogram) { + return column; + } + if (column.customLabel) { + return column; + } + return { + ...column, + timeScale: undefined, + label: adjustTimeScaleLabelSuffix(column.label, column.timeScale, undefined), + }; +} diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/suffix_formatter.ts b/x-pack/plugins/lens/public/indexpattern_datasource/suffix_formatter.ts index 5594976738efe..f5d764acab086 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/suffix_formatter.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/suffix_formatter.ts @@ -10,12 +10,19 @@ import { FormatFactory } from '../types'; import { TimeScaleUnit } from './time_scale'; const unitSuffixes: Record = { - s: i18n.translate('xpack.lens.fieldFormats.suffix.s', { defaultMessage: '/h' }), + s: i18n.translate('xpack.lens.fieldFormats.suffix.s', { defaultMessage: '/s' }), m: i18n.translate('xpack.lens.fieldFormats.suffix.m', { defaultMessage: '/m' }), h: i18n.translate('xpack.lens.fieldFormats.suffix.h', { defaultMessage: '/h' }), d: i18n.translate('xpack.lens.fieldFormats.suffix.d', { defaultMessage: '/d' }), }; +export const unitSuffixesLong: Record = { + s: i18n.translate('xpack.lens.fieldFormats.longSuffix.s', { defaultMessage: 'per second' }), + m: i18n.translate('xpack.lens.fieldFormats.longSuffix.m', { defaultMessage: 'per minute' }), + h: i18n.translate('xpack.lens.fieldFormats.longSuffix.h', { defaultMessage: 'per hour' }), + d: i18n.translate('xpack.lens.fieldFormats.longSuffix.d', { defaultMessage: 'per day' }), +}; + export function getSuffixFormatter(formatFactory: FormatFactory) { return class SuffixFormatter extends FieldFormat { static id = 'suffix'; diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/time_scale.ts b/x-pack/plugins/lens/public/indexpattern_datasource/time_scale.ts index 06ff8058b1d09..ca0745493f768 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/time_scale.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/time_scale.ts @@ -87,7 +87,8 @@ export function getTimeScaleFunction(data: DataPublicPluginStart) { input, outputColumnId, inputColumnId, - outputColumnName + outputColumnName, + { allowColumnOverwrite: true } ); if (!resultColumns) { diff --git a/x-pack/plugins/lens/public/indexpattern_datasource/to_expression.ts b/x-pack/plugins/lens/public/indexpattern_datasource/to_expression.ts index 5b66d4aae77ab..7b7fc0468cf86 100644 --- a/x-pack/plugins/lens/public/indexpattern_datasource/to_expression.ts +++ b/x-pack/plugins/lens/public/indexpattern_datasource/to_expression.ts @@ -59,7 +59,6 @@ function getExpressionForLayer(layer: IndexPatternLayer, indexPattern: IndexPatt } > >; - const columnsWithFormatters = columnEntries.filter( ([, col]) => col.params && @@ -87,6 +86,45 @@ function getExpressionForLayer(layer: IndexPatternLayer, indexPattern: IndexPatt } ); + const firstDateHistogramColumn = columnEntries.find( + ([, col]) => col.operationType === 'date_histogram' + ); + + const columnsWithTimeScale = firstDateHistogramColumn + ? columnEntries.filter( + ([, col]) => + col.timeScale && + operationDefinitionMap[col.operationType].timeScalingMode && + operationDefinitionMap[col.operationType].timeScalingMode !== 'disabled' + ) + : []; + const timeScaleFunctions: ExpressionFunctionAST[] = columnsWithTimeScale.flatMap( + ([id, col]) => { + const scalingCall: ExpressionFunctionAST = { + type: 'function', + function: 'lens_time_scale', + arguments: { + dateColumnId: [firstDateHistogramColumn![0]], + inputColumnId: [id], + outputColumnId: [id], + targetUnit: [col.timeScale!], + }, + }; + + const formatCall: ExpressionFunctionAST = { + type: 'function', + function: 'lens_format_column', + arguments: { + format: [''], + columnId: [id], + parentFormat: [JSON.stringify({ id: 'suffix', params: { unit: col.timeScale } })], + }, + }; + + return [scalingCall, formatCall]; + } + ); + const allDateHistogramFields = Object.values(columns) .map((column) => column.operationType === dateHistogramOperation.type ? column.sourceField : null @@ -117,6 +155,7 @@ function getExpressionForLayer(layer: IndexPatternLayer, indexPattern: IndexPatt }, ...formatterOverrides, ...expressions, + ...timeScaleFunctions, ], }; } diff --git a/x-pack/plugins/lens/public/types.ts b/x-pack/plugins/lens/public/types.ts index 2f40f21455310..65c565087af72 100644 --- a/x-pack/plugins/lens/public/types.ts +++ b/x-pack/plugins/lens/public/types.ts @@ -540,7 +540,10 @@ export interface Visualization { * Visualizations can provide a custom icon which will open a layer-specific popover * If no icon is provided, gear icon is default */ - getLayerContextMenuIcon?: (opts: { state: T; layerId: string }) => IconType | undefined; + getLayerContextMenuIcon?: (opts: { + state: T; + layerId: string; + }) => { icon: IconType | 'gear'; label: string } | undefined; /** * The frame is telling the visualization to update or set a dimension based on user interaction diff --git a/x-pack/plugins/lens/public/xy_visualization/visualization.tsx b/x-pack/plugins/lens/public/xy_visualization/visualization.tsx index 5748e649c181e..872eb179e6a5c 100644 --- a/x-pack/plugins/lens/public/xy_visualization/visualization.tsx +++ b/x-pack/plugins/lens/public/xy_visualization/visualization.tsx @@ -300,7 +300,11 @@ export const getXyVisualization = ({ getLayerContextMenuIcon({ state, layerId }) { const layer = state.layers.find((l) => l.layerId === layerId); - return visualizationTypes.find((t) => t.id === layer?.seriesType)?.icon; + const visualizationType = visualizationTypes.find((t) => t.id === layer?.seriesType); + return { + icon: visualizationType?.icon || 'gear', + label: visualizationType?.label || '', + }; }, renderLayerContextMenu(domElement, props) { diff --git a/x-pack/plugins/lists/common/shared_exports.ts b/x-pack/plugins/lists/common/shared_exports.ts index ec9358c2cb503..9d9896e7ff898 100644 --- a/x-pack/plugins/lists/common/shared_exports.ts +++ b/x-pack/plugins/lists/common/shared_exports.ts @@ -23,6 +23,7 @@ export { EntryList, EntriesArray, NamespaceType, + NestedEntriesArray, Operator, OperatorEnum, OperatorTypeEnum, diff --git a/x-pack/plugins/lists/server/index.ts b/x-pack/plugins/lists/server/index.ts index 31f22108028a6..ea27073e3053d 100644 --- a/x-pack/plugins/lists/server/index.ts +++ b/x-pack/plugins/lists/server/index.ts @@ -11,6 +11,7 @@ import { ListPlugin } from './plugin'; // exporting these since its required at top level in siem plugin export { ListClient } from './services/lists/list_client'; +export { CreateExceptionListItemOptions } from './services/exception_lists/exception_list_client_types'; export { ExceptionListClient } from './services/exception_lists/exception_list_client'; export { ListPluginSetup } from './types'; diff --git a/x-pack/plugins/ml/common/types/saved_objects.ts b/x-pack/plugins/ml/common/types/saved_objects.ts index d6c9ad758e8c6..aa3220747e849 100644 --- a/x-pack/plugins/ml/common/types/saved_objects.ts +++ b/x-pack/plugins/ml/common/types/saved_objects.ts @@ -11,7 +11,7 @@ export interface SavedObjectResult { [jobId: string]: { success: boolean; error?: any }; } -export interface RepairSavedObjectResponse { +export interface SyncSavedObjectResponse { savedObjectsCreated: SavedObjectResult; savedObjectsDeleted: SavedObjectResult; datafeedsAdded: SavedObjectResult; diff --git a/x-pack/plugins/ml/public/application/components/job_spaces_repair/index.ts b/x-pack/plugins/ml/public/application/components/job_spaces_sync/index.ts similarity index 78% rename from x-pack/plugins/ml/public/application/components/job_spaces_repair/index.ts rename to x-pack/plugins/ml/public/application/components/job_spaces_sync/index.ts index 3a9c22c1f3688..314071d5be1d8 100644 --- a/x-pack/plugins/ml/public/application/components/job_spaces_repair/index.ts +++ b/x-pack/plugins/ml/public/application/components/job_spaces_sync/index.ts @@ -4,4 +4,4 @@ * you may not use this file except in compliance with the Elastic License. */ -export { JobSpacesRepairFlyout } from './job_spaces_repair_flyout'; +export { JobSpacesSyncFlyout } from './job_spaces_sync_flyout'; diff --git a/x-pack/plugins/ml/public/application/components/job_spaces_repair/job_spaces_repair_flyout.tsx b/x-pack/plugins/ml/public/application/components/job_spaces_sync/job_spaces_sync_flyout.tsx similarity index 59% rename from x-pack/plugins/ml/public/application/components/job_spaces_repair/job_spaces_repair_flyout.tsx rename to x-pack/plugins/ml/public/application/components/job_spaces_sync/job_spaces_sync_flyout.tsx index 47d3fe065dd66..db80d0aa330f8 100644 --- a/x-pack/plugins/ml/public/application/components/job_spaces_repair/job_spaces_repair_flyout.tsx +++ b/x-pack/plugins/ml/public/application/components/job_spaces_sync/job_spaces_sync_flyout.tsx @@ -23,34 +23,31 @@ import { } from '@elastic/eui'; import { ml } from '../../services/ml_api_service'; -import { - RepairSavedObjectResponse, - SavedObjectResult, -} from '../../../../common/types/saved_objects'; -import { RepairList } from './repair_list'; +import { SyncSavedObjectResponse, SavedObjectResult } from '../../../../common/types/saved_objects'; +import { SyncList } from './sync_list'; import { useToastNotificationService } from '../../services/toast_notification_service'; interface Props { onClose: () => void; } -export const JobSpacesRepairFlyout: FC = ({ onClose }) => { +export const JobSpacesSyncFlyout: FC = ({ onClose }) => { const { displayErrorToast, displaySuccessToast } = useToastNotificationService(); const [loading, setLoading] = useState(false); - const [repairable, setRepairable] = useState(false); - const [repairResp, setRepairResp] = useState(null); + const [canSync, setCanSync] = useState(false); + const [syncResp, setSyncResp] = useState(null); - async function loadRepairList(simulate: boolean = true) { + async function loadSyncList(simulate: boolean = true) { setLoading(true); try { - const resp = await ml.savedObjects.repairSavedObjects(simulate); - setRepairResp(resp); + const resp = await ml.savedObjects.syncSavedObjects(simulate); + setSyncResp(resp); const count = Object.values(resp).reduce((acc, cur) => acc + Object.keys(cur).length, 0); - setRepairable(count > 0); + setCanSync(count > 0); setLoading(false); return resp; } catch (error) { - // this shouldn't be hit as errors are returned per-repair task + // this shouldn't be hit as errors are returned per-sync task // as part of the response displayErrorToast(error); setLoading(false); @@ -59,32 +56,33 @@ export const JobSpacesRepairFlyout: FC = ({ onClose }) => { } useEffect(() => { - loadRepairList(); + loadSyncList(); }, []); - async function repair() { - if (repairable) { - // perform the repair - const resp = await loadRepairList(false); - // check simulate the repair again to check that all - // items have been repaired. - await loadRepairList(true); + async function sync() { + if (canSync) { + // perform the sync + const resp = await loadSyncList(false); + // check simulate the sync again to check that all + // items have been synchronized. + await loadSyncList(true); if (resp === null) { return; } const { successCount, errorCount } = getResponseCounts(resp); if (errorCount > 0) { - const title = i18n.translate('xpack.ml.management.repairSavedObjectsFlyout.repair.error', { - defaultMessage: 'Some jobs cannot be repaired.', + const title = i18n.translate('xpack.ml.management.syncSavedObjectsFlyout.sync.error', { + defaultMessage: 'Some jobs cannot be synchronized.', }); displayErrorToast(resp as any, title); return; } displaySuccessToast( - i18n.translate('xpack.ml.management.repairSavedObjectsFlyout.repair.success', { - defaultMessage: '{successCount} {successCount, plural, one {job} other {jobs}} repaired', + i18n.translate('xpack.ml.management.syncSavedObjectsFlyout.sync.success', { + defaultMessage: + '{successCount} {successCount, plural, one {job} other {jobs}} synchronized', values: { successCount }, }) ); @@ -98,8 +96,8 @@ export const JobSpacesRepairFlyout: FC = ({ onClose }) => {

@@ -108,33 +106,29 @@ export const JobSpacesRepairFlyout: FC = ({ onClose }) => { - + - + @@ -145,7 +139,7 @@ export const JobSpacesRepairFlyout: FC = ({ onClose }) => { ); }; -function getResponseCounts(resp: RepairSavedObjectResponse) { +function getResponseCounts(resp: SyncSavedObjectResponse) { let successCount = 0; let errorCount = 0; Object.values(resp).forEach((result: SavedObjectResult) => { diff --git a/x-pack/plugins/ml/public/application/components/job_spaces_repair/repair_list.tsx b/x-pack/plugins/ml/public/application/components/job_spaces_sync/sync_list.tsx similarity index 60% rename from x-pack/plugins/ml/public/application/components/job_spaces_repair/repair_list.tsx rename to x-pack/plugins/ml/public/application/components/job_spaces_sync/sync_list.tsx index 3eab255ba34e6..573842c2f35e7 100644 --- a/x-pack/plugins/ml/public/application/components/job_spaces_repair/repair_list.tsx +++ b/x-pack/plugins/ml/public/application/components/job_spaces_sync/sync_list.tsx @@ -9,38 +9,36 @@ import { FormattedMessage } from '@kbn/i18n/react'; import { EuiText, EuiTitle, EuiAccordion, EuiTextColor, EuiHorizontalRule } from '@elastic/eui'; -import { RepairSavedObjectResponse } from '../../../../common/types/saved_objects'; +import { SyncSavedObjectResponse } from '../../../../common/types/saved_objects'; -export const RepairList: FC<{ repairItems: RepairSavedObjectResponse | null }> = ({ - repairItems, -}) => { - if (repairItems === null) { +export const SyncList: FC<{ syncItems: SyncSavedObjectResponse | null }> = ({ syncItems }) => { + if (syncItems === null) { return null; } return ( <> - + - + - + - + ); }; -const SavedObjectsCreated: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repairItems }) => { - const items = Object.keys(repairItems.savedObjectsCreated); +const SavedObjectsCreated: FC<{ syncItems: SyncSavedObjectResponse }> = ({ syncItems }) => { + const items = Object.keys(syncItems.savedObjectsCreated); const title = ( <> @@ -48,7 +46,7 @@ const SavedObjectsCreated: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r

@@ -59,7 +57,7 @@ const SavedObjectsCreated: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r

@@ -67,11 +65,11 @@ const SavedObjectsCreated: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r ); - return ; + return ; }; -const SavedObjectsDeleted: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repairItems }) => { - const items = Object.keys(repairItems.savedObjectsDeleted); +const SavedObjectsDeleted: FC<{ syncItems: SyncSavedObjectResponse }> = ({ syncItems }) => { + const items = Object.keys(syncItems.savedObjectsDeleted); const title = ( <> @@ -79,7 +77,7 @@ const SavedObjectsDeleted: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r

@@ -90,7 +88,7 @@ const SavedObjectsDeleted: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r

@@ -98,11 +96,11 @@ const SavedObjectsDeleted: FC<{ repairItems: RepairSavedObjectResponse }> = ({ r ); - return ; + return ; }; -const DatafeedsAdded: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repairItems }) => { - const items = Object.keys(repairItems.datafeedsAdded); +const DatafeedsAdded: FC<{ syncItems: SyncSavedObjectResponse }> = ({ syncItems }) => { + const items = Object.keys(syncItems.datafeedsAdded); const title = ( <> @@ -110,7 +108,7 @@ const DatafeedsAdded: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repair

@@ -121,7 +119,7 @@ const DatafeedsAdded: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repair

@@ -129,11 +127,11 @@ const DatafeedsAdded: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repair ); - return ; + return ; }; -const DatafeedsRemoved: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repairItems }) => { - const items = Object.keys(repairItems.datafeedsRemoved); +const DatafeedsRemoved: FC<{ syncItems: SyncSavedObjectResponse }> = ({ syncItems }) => { + const items = Object.keys(syncItems.datafeedsRemoved); const title = ( <> @@ -141,7 +139,7 @@ const DatafeedsRemoved: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repa

@@ -152,7 +150,7 @@ const DatafeedsRemoved: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repa

@@ -160,23 +158,21 @@ const DatafeedsRemoved: FC<{ repairItems: RepairSavedObjectResponse }> = ({ repa ); - return ; + return ; }; -const RepairItem: FC<{ id: string; title: JSX.Element; items: string[] }> = ({ +const SyncItem: FC<{ id: string; title: JSX.Element; items: string[] }> = ({ id, title, items, }) => ( - {items.length && ( -

    - {items.map((item) => ( -
  • {item}
    • - ))} -
- )} +
    + {items.map((item) => ( +
  • {item}
    • + ))} +
); diff --git a/x-pack/plugins/ml/public/application/management/jobs_list/components/jobs_list_page/jobs_list_page.tsx b/x-pack/plugins/ml/public/application/management/jobs_list/components/jobs_list_page/jobs_list_page.tsx index 8ad18e2b821b6..18d45c02a3c95 100644 --- a/x-pack/plugins/ml/public/application/management/jobs_list/components/jobs_list_page/jobs_list_page.tsx +++ b/x-pack/plugins/ml/public/application/management/jobs_list/components/jobs_list_page/jobs_list_page.tsx @@ -39,7 +39,7 @@ import { DataFrameAnalyticsList } from '../../../../data_frame_analytics/pages/a import { AccessDeniedPage } from '../access_denied_page'; import { SharePluginStart } from '../../../../../../../../../src/plugins/share/public'; import { SpacesPluginStart } from '../../../../../../../spaces/public'; -import { JobSpacesRepairFlyout } from '../../../../components/job_spaces_repair'; +import { JobSpacesSyncFlyout } from '../../../../components/job_spaces_sync'; import { getDefaultAnomalyDetectionJobsListState } from '../../../../jobs/jobs_list/jobs'; import { getMlGlobalServices } from '../../../../app'; import { ListingPageUrlState } from '../../../../../../common/types/common'; @@ -125,7 +125,7 @@ export const JobsListPage: FC<{ const spacesEnabled = spaces !== undefined; const [initialized, setInitialized] = useState(false); const [accessDenied, setAccessDenied] = useState(false); - const [showRepairFlyout, setShowRepairFlyout] = useState(false); + const [showSyncFlyout, setShowSyncFlyout] = useState(false); const [isMlEnabledInSpace, setIsMlEnabledInSpace] = useState(false); const tabs = useTabs(isMlEnabledInSpace, spacesEnabled); const [currentTabId, setCurrentTabId] = useState(tabs[0].id); @@ -184,8 +184,8 @@ export const JobsListPage: FC<{ ); } - function onCloseRepairFlyout() { - setShowRepairFlyout(false); + function onCloseSyncFlyout() { + setShowSyncFlyout(false); } if (accessDenied) { @@ -244,12 +244,12 @@ export const JobsListPage: FC<{ {spacesEnabled && ( <> - setShowRepairFlyout(true)}> - {i18n.translate('xpack.ml.management.jobsList.repairFlyoutButton', { - defaultMessage: 'Repair saved objects', + setShowSyncFlyout(true)}> + {i18n.translate('xpack.ml.management.jobsList.syncFlyoutButton', { + defaultMessage: 'Synchronize saved objects', })} - {showRepairFlyout && } + {showSyncFlyout && } )} diff --git a/x-pack/plugins/ml/public/application/services/ml_api_service/saved_objects.ts b/x-pack/plugins/ml/public/application/services/ml_api_service/saved_objects.ts index b47cf3f62871c..e821fa3da4d66 100644 --- a/x-pack/plugins/ml/public/application/services/ml_api_service/saved_objects.ts +++ b/x-pack/plugins/ml/public/application/services/ml_api_service/saved_objects.ts @@ -11,7 +11,7 @@ import { HttpService } from '../http_service'; import { basePath } from './index'; import { JobType, - RepairSavedObjectResponse, + SyncSavedObjectResponse, SavedObjectResult, JobsSpacesResponse, } from '../../../../common/types/saved_objects'; @@ -40,9 +40,9 @@ export const savedObjectsApiProvider = (httpService: HttpService) => ({ }); }, - repairSavedObjects(simulate: boolean = false) { - return httpService.http({ - path: `${basePath()}/saved_objects/repair`, + syncSavedObjects(simulate: boolean = false) { + return httpService.http({ + path: `${basePath()}/saved_objects/sync`, method: 'GET', query: { simulate }, }); diff --git a/x-pack/plugins/ml/server/routes/apidoc.json b/x-pack/plugins/ml/server/routes/apidoc.json index 5672824f3d040..85df7228fe929 100644 --- a/x-pack/plugins/ml/server/routes/apidoc.json +++ b/x-pack/plugins/ml/server/routes/apidoc.json @@ -145,7 +145,7 @@ "JobSavedObjects", "SavedObjectsStatus", - "RepairJobSavedObjects", + "SyncJobSavedObjects", "InitializeJobSavedObjects", "AssignJobsToSpaces", "RemoveJobsFromSpaces", diff --git a/x-pack/plugins/ml/server/routes/saved_objects.ts b/x-pack/plugins/ml/server/routes/saved_objects.ts index 3ba69b0d6b505..57c6084d9971b 100644 --- a/x-pack/plugins/ml/server/routes/saved_objects.ts +++ b/x-pack/plugins/ml/server/routes/saved_objects.ts @@ -6,8 +6,8 @@ import { wrapError } from '../client/error_wrapper'; import { RouteInitialization, SavedObjectsRouteDeps } from '../types'; -import { checksFactory, repairFactory } from '../saved_objects'; -import { jobsAndSpaces, repairJobObjects, jobTypeSchema } from './schemas/saved_objects'; +import { checksFactory, syncSavedObjectsFactory } from '../saved_objects'; +import { jobsAndSpaces, syncJobObjects, jobTypeSchema } from './schemas/saved_objects'; import { jobIdsSchema } from './schemas/job_service_schema'; /** @@ -50,8 +50,8 @@ export function savedObjectsRoutes( /** * @apiGroup JobSavedObjects * - * @api {get} /api/ml/saved_objects/repair Repair job saved objects - * @apiName RepairJobSavedObjects + * @api {get} /api/ml/saved_objects/sync Sync job saved objects + * @apiName SyncJobSavedObjects * @apiDescription Create saved objects for jobs which are missing them. * Delete saved objects for jobs which no longer exist. * Update missing datafeed ids in saved objects for datafeeds which exist. @@ -60,9 +60,9 @@ export function savedObjectsRoutes( */ router.get( { - path: '/api/ml/saved_objects/repair', + path: '/api/ml/saved_objects/sync', validate: { - query: repairJobObjects, + query: syncJobObjects, }, options: { tags: ['access:ml:canCreateJob', 'access:ml:canCreateDataFrameAnalytics'], @@ -71,8 +71,8 @@ export function savedObjectsRoutes( routeGuard.fullLicenseAPIGuard(async ({ client, request, response, jobSavedObjectService }) => { try { const { simulate } = request.query; - const { repairJobs } = repairFactory(client, jobSavedObjectService); - const savedObjects = await repairJobs(simulate); + const { syncSavedObjects } = syncSavedObjectsFactory(client, jobSavedObjectService); + const savedObjects = await syncSavedObjects(simulate); return response.ok({ body: savedObjects, @@ -95,7 +95,7 @@ export function savedObjectsRoutes( { path: '/api/ml/saved_objects/initialize', validate: { - query: repairJobObjects, + query: syncJobObjects, }, options: { tags: ['access:ml:canCreateJob', 'access:ml:canCreateDataFrameAnalytics'], @@ -104,7 +104,7 @@ export function savedObjectsRoutes( routeGuard.fullLicenseAPIGuard(async ({ client, request, response, jobSavedObjectService }) => { try { const { simulate } = request.query; - const { initSavedObjects } = repairFactory(client, jobSavedObjectService); + const { initSavedObjects } = syncSavedObjectsFactory(client, jobSavedObjectService); const savedObjects = await initSavedObjects(simulate); return response.ok({ diff --git a/x-pack/plugins/ml/server/routes/schemas/saved_objects.ts b/x-pack/plugins/ml/server/routes/schemas/saved_objects.ts index 6b8c64714a82c..c2d091bd16052 100644 --- a/x-pack/plugins/ml/server/routes/schemas/saved_objects.ts +++ b/x-pack/plugins/ml/server/routes/schemas/saved_objects.ts @@ -12,7 +12,7 @@ export const jobsAndSpaces = schema.object({ spaces: schema.arrayOf(schema.string()), }); -export const repairJobObjects = schema.object({ simulate: schema.maybe(schema.boolean()) }); +export const syncJobObjects = schema.object({ simulate: schema.maybe(schema.boolean()) }); export const jobTypeSchema = schema.object({ jobType: schema.string(), diff --git a/x-pack/plugins/ml/server/saved_objects/index.ts b/x-pack/plugins/ml/server/saved_objects/index.ts index fdd675f40d083..a082f3c3ec54a 100644 --- a/x-pack/plugins/ml/server/saved_objects/index.ts +++ b/x-pack/plugins/ml/server/saved_objects/index.ts @@ -7,6 +7,6 @@ export { setupSavedObjects } from './saved_objects'; export { JobObject, JobSavedObjectService, jobSavedObjectServiceFactory } from './service'; export { checksFactory } from './checks'; -export { repairFactory } from './repair'; +export { syncSavedObjectsFactory } from './sync'; export { jobSavedObjectsInitializationFactory } from './initialization'; export { savedObjectClientsFactory } from './util'; diff --git a/x-pack/plugins/ml/server/saved_objects/initialization/initialization.ts b/x-pack/plugins/ml/server/saved_objects/initialization/initialization.ts index 5edf35c033177..a81fc925b824b 100644 --- a/x-pack/plugins/ml/server/saved_objects/initialization/initialization.ts +++ b/x-pack/plugins/ml/server/saved_objects/initialization/initialization.ts @@ -6,7 +6,7 @@ import { IScopedClusterClient, CoreStart, SavedObjectsClientContract } from 'kibana/server'; import { savedObjectClientsFactory } from '../util'; -import { repairFactory } from '../repair'; +import { syncSavedObjectsFactory } from '../sync'; import { jobSavedObjectServiceFactory, JobObject } from '../service'; import { mlLog } from '../../lib/log'; import { ML_SAVED_OBJECT_TYPE } from '../../../common/types/saved_objects'; @@ -58,7 +58,7 @@ export function jobSavedObjectsInitializationFactory( // create space overrides for specific jobs const jobSpaceOverrides = await createJobSpaceOverrides(client); // initialize jobs - const { initSavedObjects } = repairFactory(client, jobSavedObjectService); + const { initSavedObjects } = syncSavedObjectsFactory(client, jobSavedObjectService); const { jobs } = await initSavedObjects(false, jobSpaceOverrides); mlLog.info(`${jobs.length} job saved objects initialized`); } catch (error) { diff --git a/x-pack/plugins/ml/server/saved_objects/initialization/space_overrides/space_overrides.ts b/x-pack/plugins/ml/server/saved_objects/initialization/space_overrides/space_overrides.ts index d8c713888051f..969024ee58b51 100644 --- a/x-pack/plugins/ml/server/saved_objects/initialization/space_overrides/space_overrides.ts +++ b/x-pack/plugins/ml/server/saved_objects/initialization/space_overrides/space_overrides.ts @@ -5,7 +5,7 @@ */ import { IScopedClusterClient } from 'kibana/server'; -import type { JobSpaceOverrides } from '../../repair'; +import type { JobSpaceOverrides } from '../../sync'; import { logJobsSpaces } from './logs'; import { metricsJobsSpaces } from './metrics'; diff --git a/x-pack/plugins/ml/server/saved_objects/repair.ts b/x-pack/plugins/ml/server/saved_objects/sync.ts similarity index 97% rename from x-pack/plugins/ml/server/saved_objects/repair.ts rename to x-pack/plugins/ml/server/saved_objects/sync.ts index 692217e5fac36..16e0520567056 100644 --- a/x-pack/plugins/ml/server/saved_objects/repair.ts +++ b/x-pack/plugins/ml/server/saved_objects/sync.ts @@ -9,7 +9,7 @@ import { IScopedClusterClient } from 'kibana/server'; import type { JobObject, JobSavedObjectService } from './service'; import { JobType, - RepairSavedObjectResponse, + SyncSavedObjectResponse, InitializeSavedObjectResponse, } from '../../common/types/saved_objects'; import { checksFactory } from './checks'; @@ -23,14 +23,14 @@ export interface JobSpaceOverrides { }; } -export function repairFactory( +export function syncSavedObjectsFactory( client: IScopedClusterClient, jobSavedObjectService: JobSavedObjectService ) { const { checkStatus } = checksFactory(client, jobSavedObjectService); - async function repairJobs(simulate: boolean = false) { - const results: RepairSavedObjectResponse = { + async function syncSavedObjects(simulate: boolean = false) { + const results: SyncSavedObjectResponse = { savedObjectsCreated: {}, savedObjectsDeleted: {}, datafeedsAdded: {}, @@ -232,5 +232,5 @@ export function repairFactory( return results; } - return { checkStatus, repairJobs, initSavedObjects }; + return { checkStatus, syncSavedObjects, initSavedObjects }; } diff --git a/x-pack/plugins/monitoring/server/kibana_monitoring/__tests__/bulk_uploader.js b/x-pack/plugins/monitoring/server/kibana_monitoring/__tests__/bulk_uploader.js index da12bde966091..1aa9e49bc5f35 100644 --- a/x-pack/plugins/monitoring/server/kibana_monitoring/__tests__/bulk_uploader.js +++ b/x-pack/plugins/monitoring/server/kibana_monitoring/__tests__/bulk_uploader.js @@ -71,7 +71,6 @@ describe('BulkUploader', () => { type: 'type_collector_test', fetch: noop, // empty payloads, isReady: () => true, - formatForBulkUpload: (result) => result, }, ]); @@ -111,13 +110,11 @@ describe('BulkUploader', () => { type: 'type_collector_test', fetch: noop, // empty payloads, isReady: () => false, - formatForBulkUpload: (result) => result, }, { type: 'type_collector_test2', fetch: noop, // empty payloads, isReady: () => true, - formatForBulkUpload: (result) => result, }, ]); @@ -153,7 +150,6 @@ describe('BulkUploader', () => { { fetch: () => ({ type: 'type_collector_test', result: { testData: 12345 } }), isReady: () => true, - formatForBulkUpload: (result) => result, }, ]); const uploader = new BulkUploader({ ...server, interval: FETCH_INTERVAL }); @@ -191,13 +187,11 @@ describe('BulkUploader', () => { { fetch: usageCollectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: true, }, { fetch: collectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: false, }, ]); @@ -223,7 +217,6 @@ describe('BulkUploader', () => { { fetch: usageCollectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: true, }, ]); @@ -253,13 +246,11 @@ describe('BulkUploader', () => { { fetch: statsCollectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: false, }, { fetch: usageCollectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: true, }, ]); @@ -290,13 +281,11 @@ describe('BulkUploader', () => { { fetch: usageCollectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: true, }, { fetch: collectorFetch, isReady: () => true, - formatForBulkUpload: (result) => result, isUsageCollector: false, }, ]); diff --git a/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_settings_collector.ts b/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_settings_collector.ts index 858c50790fc2e..44ae0147f6c52 100644 --- a/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_settings_collector.ts +++ b/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_settings_collector.ts @@ -89,7 +89,6 @@ export function getSettingsCollector( ) { return usageCollection.makeStatsCollector< EmailSettingData | undefined, - unknown, false, KibanaSettingsCollectorExtraOptions >({ diff --git a/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_usage_collector.ts b/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_usage_collector.ts index 038042f109817..e5171c4901dd4 100644 --- a/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_usage_collector.ts +++ b/x-pack/plugins/monitoring/server/kibana_monitoring/collectors/get_usage_collector.ts @@ -20,7 +20,7 @@ export function getMonitoringUsageCollector( config: MonitoringConfig, legacyEsClient: ILegacyClusterClient ) { - return usageCollection.makeUsageCollector({ + return usageCollection.makeUsageCollector({ type: 'monitoring', isReady: () => true, schema: { diff --git a/x-pack/plugins/monitoring/server/telemetry_collection/get_kibana_stats.ts b/x-pack/plugins/monitoring/server/telemetry_collection/get_kibana_stats.ts index 3bf1d087b973a..57e75d9c9c12e 100644 --- a/x-pack/plugins/monitoring/server/telemetry_collection/get_kibana_stats.ts +++ b/x-pack/plugins/monitoring/server/telemetry_collection/get_kibana_stats.ts @@ -114,7 +114,6 @@ export function getUsageStats(rawStats: SearchResponse) { } = currUsage; // Stats filtered by telemetry collectors need to be flattened since they're pulled in a generic way. - // A plugin might not provide flat stats if it implements formatForBulkUpload in its collector. // e.g: we want `xpack.reporting` to just be `reporting` const plugins = { ...pluginsTop, ...xpack }; diff --git a/x-pack/plugins/monitoring/server/telemetry_collection/register_monitoring_telemetry_collection.ts b/x-pack/plugins/monitoring/server/telemetry_collection/register_monitoring_telemetry_collection.ts index 91d6c2374acba..8351c30a4f712 100644 --- a/x-pack/plugins/monitoring/server/telemetry_collection/register_monitoring_telemetry_collection.ts +++ b/x-pack/plugins/monitoring/server/telemetry_collection/register_monitoring_telemetry_collection.ts @@ -23,7 +23,6 @@ export function registerMonitoringTelemetryCollection( ) { const monitoringStatsCollector = usageCollection.makeStatsCollector< UsageStatsPayload[], - unknown, true, MonitoringCollectorOptions >({ diff --git a/x-pack/plugins/painless_lab/public/application/components/editor.tsx b/x-pack/plugins/painless_lab/public/application/components/editor.tsx index 5971c0de5c4ef..ac7a5c9ad531e 100644 --- a/x-pack/plugins/painless_lab/public/application/components/editor.tsx +++ b/x-pack/plugins/painless_lab/public/application/components/editor.tsx @@ -4,15 +4,19 @@ * you may not use this file except in compliance with the Elastic License. */ import React from 'react'; -import { PainlessLang } from '@kbn/monaco'; +import { PainlessLang, PainlessContext } from '@kbn/monaco'; + import { CodeEditor } from '../../../../../../src/plugins/kibana_react/public'; interface Props { code: string; onChange: (code: string) => void; + context: PainlessContext; } -export function Editor({ code, onChange }: Props) { +export function Editor({ code, onChange, context }: Props) { + const suggestionProvider = PainlessLang.getSuggestionProvider(context); + return ( ); diff --git a/x-pack/plugins/painless_lab/public/application/components/main.tsx b/x-pack/plugins/painless_lab/public/application/components/main.tsx index 06499994e5609..aaf1e925c0cee 100644 --- a/x-pack/plugins/painless_lab/public/application/components/main.tsx +++ b/x-pack/plugins/painless_lab/public/application/components/main.tsx @@ -51,7 +51,11 @@ export const Main: React.FunctionComponent = () => {

- updatePayload({ code: nextCode })} /> + updatePayload({ code: nextCode })} + /> diff --git a/x-pack/plugins/painless_lab/public/application/components/output_pane/context_tab.tsx b/x-pack/plugins/painless_lab/public/application/components/output_pane/context_tab.tsx index eab91b0b0c212..24889f2bc4a4e 100644 --- a/x-pack/plugins/painless_lab/public/application/components/output_pane/context_tab.tsx +++ b/x-pack/plugins/painless_lab/public/application/components/output_pane/context_tab.tsx @@ -18,6 +18,7 @@ import { } from '@elastic/eui'; import { FormattedMessage } from '@kbn/i18n/react'; import { i18n } from '@kbn/i18n'; +import { PainlessContext } from '@kbn/monaco'; import { CodeEditor } from '../../../../../../../src/plugins/kibana_react/public'; import { painlessContextOptions } from '../../constants'; @@ -64,7 +65,7 @@ export const ContextTab: FunctionComponent = () => { updatePayload({ context: nextContext })} + onChange={(nextContext: PainlessContext) => updatePayload({ context: nextContext })} itemLayoutAlign="top" hasDividers fullWidth diff --git a/x-pack/plugins/painless_lab/public/application/constants.tsx b/x-pack/plugins/painless_lab/public/application/constants.tsx index b2c284aa97420..c6293f8238341 100644 --- a/x-pack/plugins/painless_lab/public/application/constants.tsx +++ b/x-pack/plugins/painless_lab/public/application/constants.tsx @@ -8,6 +8,8 @@ import React from 'react'; import { EuiText } from '@elastic/eui'; import { i18n } from '@kbn/i18n'; +import { PainlessContext } from '@kbn/monaco'; +import { EuiSuperSelectOption } from '@elastic/eui'; const defaultLabel = i18n.translate('xpack.painlessLab.contextDefaultLabel', { defaultMessage: 'Basic', @@ -21,7 +23,7 @@ const scoreLabel = i18n.translate('xpack.painlessLab.contextScoreLabel', { defaultMessage: 'Score', }); -export const painlessContextOptions = [ +export const painlessContextOptions: Array> = [ { value: 'painless_test', inputDisplay: defaultLabel, diff --git a/x-pack/plugins/painless_lab/public/application/types.ts b/x-pack/plugins/painless_lab/public/application/types.ts index d800558ef7ecc..3114f17ad3086 100644 --- a/x-pack/plugins/painless_lab/public/application/types.ts +++ b/x-pack/plugins/painless_lab/public/application/types.ts @@ -4,13 +4,15 @@ * you may not use this file except in compliance with the Elastic License. */ +import { PainlessContext } from '@kbn/monaco'; + export interface Store { payload: Payload; validation: Validation; } export interface Payload { - context: string; + context: PainlessContext; code: string; parameters: string; index: string; diff --git a/x-pack/plugins/reporting/server/usage/reporting_usage_collector.test.ts b/x-pack/plugins/reporting/server/usage/reporting_usage_collector.test.ts index fff18353c58b0..7cae5e9b6f956 100644 --- a/x-pack/plugins/reporting/server/usage/reporting_usage_collector.test.ts +++ b/x-pack/plugins/reporting/server/usage/reporting_usage_collector.test.ts @@ -463,7 +463,6 @@ describe('Ready for collection observable', () => { expect(args).toMatchInlineSnapshot(` Object { "fetch": [Function], - "formatForBulkUpload": [Function], "isReady": [Function], "schema": Object { "PNG": Object { diff --git a/x-pack/plugins/reporting/server/usage/reporting_usage_collector.ts b/x-pack/plugins/reporting/server/usage/reporting_usage_collector.ts index 2ef7a7995b839..f4209730b68ce 100644 --- a/x-pack/plugins/reporting/server/usage/reporting_usage_collector.ts +++ b/x-pack/plugins/reporting/server/usage/reporting_usage_collector.ts @@ -14,16 +14,6 @@ import { getReportingUsage } from './get_reporting_usage'; import { ReportingUsageType } from './types'; import { reportingSchema } from './schema'; -// places the reporting data as kibana stats -const METATYPE = 'kibana_stats'; - -interface XpackBulkUpload { - usage: { - xpack: { - reporting: ReportingUsageType; - }; - }; -} /* * @return {Object} kibana usage stats type collection object */ @@ -34,7 +24,7 @@ export function getReportingUsageCollector( exportTypesRegistry: ExportTypesRegistry, isReady: () => Promise ) { - return usageCollection.makeUsageCollector({ + return usageCollection.makeUsageCollector({ type: 'reporting', fetch: ({ callCluster }: CollectorFetchContext) => { const config = reporting.getConfig(); @@ -42,23 +32,6 @@ export function getReportingUsageCollector( }, isReady, schema: reportingSchema, - /* - * Format the response data into a model for internal upload - * 1. Make this data part of the "kibana_stats" type - * 2. Organize the payload in the usage.xpack.reporting namespace of the data payload - */ - formatForBulkUpload: (result: ReportingUsageType) => { - return { - type: METATYPE, - payload: { - usage: { - xpack: { - reporting: result, - }, - }, - }, - }; - }, }); } diff --git a/x-pack/plugins/security_solution/common/endpoint/constants.ts b/x-pack/plugins/security_solution/common/endpoint/constants.ts index 8e19c2e8f219d..40e80840909a7 100644 --- a/x-pack/plugins/security_solution/common/endpoint/constants.ts +++ b/x-pack/plugins/security_solution/common/endpoint/constants.ts @@ -14,7 +14,6 @@ export const telemetryIndexPattern = 'metrics-endpoint.telemetry-*'; export const LIMITED_CONCURRENCY_ENDPOINT_ROUTE_TAG = 'endpoint:limited-concurrency'; export const LIMITED_CONCURRENCY_ENDPOINT_COUNT = 100; -export const TRUSTED_APPS_SUPPORTED_OS_TYPES: readonly string[] = ['macos', 'windows', 'linux']; export const TRUSTED_APPS_LIST_API = '/api/endpoint/trusted_apps'; export const TRUSTED_APPS_CREATE_API = '/api/endpoint/trusted_apps'; export const TRUSTED_APPS_DELETE_API = '/api/endpoint/trusted_apps/{id}'; diff --git a/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.test.ts b/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.test.ts index f83496737bcc6..fc99268f6f031 100644 --- a/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.test.ts +++ b/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.test.ts @@ -5,6 +5,7 @@ */ import { GetTrustedAppsRequestSchema, PostTrustedAppCreateRequestSchema } from './trusted_apps'; +import { ConditionEntryField, OperatingSystem } from '../types'; describe('When invoking Trusted Apps Schema', () => { describe('for GET List', () => { @@ -70,93 +71,62 @@ describe('When invoking Trusted Apps Schema', () => { }); describe('for POST Create', () => { - const getCreateTrustedAppItem = () => ({ + const createConditionEntry = (data?: T) => ({ + field: ConditionEntryField.PATH, + type: 'match', + operator: 'included', + value: 'c:/programs files/Anti-Virus', + ...(data || {}), + }); + const createNewTrustedApp = (data?: T) => ({ name: 'Some Anti-Virus App', description: 'this one is ok', os: 'windows', - entries: [ - { - field: 'process.executable.caseless', - type: 'match', - operator: 'included', - value: 'c:/programs files/Anti-Virus', - }, - ], + entries: [createConditionEntry()], + ...(data || {}), }); const body = PostTrustedAppCreateRequestSchema.body; it('should not error on a valid message', () => { - const bodyMsg = getCreateTrustedAppItem(); + const bodyMsg = createNewTrustedApp(); expect(body.validate(bodyMsg)).toStrictEqual(bodyMsg); }); it('should validate `name` is required', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - name: undefined, - }; - expect(() => body.validate(bodyMsg)).toThrow(); + expect(() => body.validate(createNewTrustedApp({ name: undefined }))).toThrow(); }); it('should validate `name` value to be non-empty', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - name: '', - }; - expect(() => body.validate(bodyMsg)).toThrow(); + expect(() => body.validate(createNewTrustedApp({ name: '' }))).toThrow(); }); it('should validate `description` as optional', () => { - const { description, ...bodyMsg } = getCreateTrustedAppItem(); + const { description, ...bodyMsg } = createNewTrustedApp(); expect(body.validate(bodyMsg)).toStrictEqual(bodyMsg); }); it('should validate `os` to to only accept known values', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - os: undefined, - }; + const bodyMsg = createNewTrustedApp({ os: undefined }); expect(() => body.validate(bodyMsg)).toThrow(); - const bodyMsg2 = { - ...bodyMsg, - os: '', - }; - expect(() => body.validate(bodyMsg2)).toThrow(); + expect(() => body.validate({ ...bodyMsg, os: '' })).toThrow(); - const bodyMsg3 = { - ...bodyMsg, - os: 'winz', - }; - expect(() => body.validate(bodyMsg3)).toThrow(); + expect(() => body.validate({ ...bodyMsg, os: 'winz' })).toThrow(); - ['linux', 'macos', 'windows'].forEach((os) => { - expect(() => { - body.validate({ - ...bodyMsg, - os, - }); - }).not.toThrow(); + [OperatingSystem.LINUX, OperatingSystem.MAC, OperatingSystem.WINDOWS].forEach((os) => { + expect(() => body.validate({ ...bodyMsg, os })).not.toThrow(); }); }); it('should validate `entries` as required', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: undefined, - }; - expect(() => body.validate(bodyMsg)).toThrow(); + expect(() => body.validate(createNewTrustedApp({ entries: undefined }))).toThrow(); - const { entries, ...bodyMsg2 } = getCreateTrustedAppItem(); + const { entries, ...bodyMsg2 } = createNewTrustedApp(); expect(() => body.validate(bodyMsg2)).toThrow(); }); it('should validate `entries` to have at least 1 item', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [], - }; - expect(() => body.validate(bodyMsg)).toThrow(); + expect(() => body.validate(createNewTrustedApp({ entries: [] }))).toThrow(); }); describe('when `entries` are defined', () => { @@ -165,171 +135,163 @@ describe('When invoking Trusted Apps Schema', () => { const VALID_HASH_SHA1 = 'aedb279e378BED6C2DB3C9DC9e12ba635e0b391c'; const VALID_HASH_SHA256 = 'A4370C0CF81686C0B696FA6261c9d3e0d810ae704ab8301839dffd5d5112f476'; - const getTrustedAppItemEntryItem = () => getCreateTrustedAppItem().entries[0]; - it('should validate `entry.field` is required', () => { - const { field, ...entry } = getTrustedAppItemEntryItem(); - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [entry], - }; + const { field, ...entry } = createConditionEntry(); + expect(() => body.validate(createNewTrustedApp({ entries: [entry] }))).toThrow(); + }); + + it('should validate `entry.field` does not accept empty values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ field: '' })], + }); expect(() => body.validate(bodyMsg)).toThrow(); }); - it('should validate `entry.field` is limited to known values', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: '', - }, - ], - }; + it('should validate `entry.field` does not accept unknown values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ field: 'invalid value' })], + }); expect(() => body.validate(bodyMsg)).toThrow(); + }); - const bodyMsg2 = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'invalid value', - }, - ], - }; - expect(() => body.validate(bodyMsg2)).toThrow(); - - [ - { - field: 'process.hash.*', - value: 'A4370C0CF81686C0B696FA6261c9d3e0d810ae704ab8301839dffd5d5112f476', - }, - { field: 'process.executable.caseless', value: '/tmp/dir1' }, - ].forEach((partialEntry) => { - const bodyMsg3 = { - ...getCreateTrustedAppItem(), + it('should validate `entry.field` accepts hash field name for all os values', () => { + [OperatingSystem.LINUX, OperatingSystem.MAC, OperatingSystem.WINDOWS].forEach((os) => { + const bodyMsg3 = createNewTrustedApp({ + os, entries: [ - { - ...getTrustedAppItemEntryItem(), - ...partialEntry, - }, + createConditionEntry({ + field: ConditionEntryField.HASH, + value: 'A4370C0CF81686C0B696FA6261c9d3e0d810ae704ab8301839dffd5d5112f476', + }), ], - }; + }); + + expect(() => body.validate(bodyMsg3)).not.toThrow(); + }); + }); + + it('should validate `entry.field` accepts path field name for all os values', () => { + [OperatingSystem.LINUX, OperatingSystem.MAC, OperatingSystem.WINDOWS].forEach((os) => { + const bodyMsg3 = createNewTrustedApp({ + os, + entries: [ + createConditionEntry({ field: ConditionEntryField.PATH, value: '/tmp/dir1' }), + ], + }); expect(() => body.validate(bodyMsg3)).not.toThrow(); }); }); - it('should validate `entry.type` is limited to known values', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), + it('should validate `entry.field` accepts signer field name for windows os value', () => { + const bodyMsg3 = createNewTrustedApp({ + os: 'windows', entries: [ - { - ...getTrustedAppItemEntryItem(), - type: 'invalid', - }, + createConditionEntry({ field: ConditionEntryField.SIGNER, value: 'Microsoft' }), ], - }; + }); + + expect(() => body.validate(bodyMsg3)).not.toThrow(); + }); + + it('should validate `entry.field` does not accept signer field name for linux and macos os values', () => { + [OperatingSystem.LINUX, OperatingSystem.MAC].forEach((os) => { + const bodyMsg3 = createNewTrustedApp({ + os, + entries: [ + createConditionEntry({ field: ConditionEntryField.SIGNER, value: 'Microsoft' }), + ], + }); + + expect(() => body.validate(bodyMsg3)).toThrow(); + }); + }); + + it('should validate `entry.type` does not accept unknown values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ type: 'invalid' })], + }); expect(() => body.validate(bodyMsg)).toThrow(); + }); - // Allow `match` - const bodyMsg2 = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - type: 'match', - }, - ], - }; - expect(() => body.validate(bodyMsg2)).not.toThrow(); + it('should validate `entry.type` accepts known values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ type: 'match' })], + }); + expect(() => body.validate(bodyMsg)).not.toThrow(); }); - it('should validate `entry.operator` is limited to known values', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - operator: 'invalid', - }, - ], - }; + it('should validate `entry.operator` does not accept unknown values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ operator: 'invalid' })], + }); expect(() => body.validate(bodyMsg)).toThrow(); + }); - // Allow `match` - const bodyMsg2 = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - operator: 'included', - }, - ], - }; - expect(() => body.validate(bodyMsg2)).not.toThrow(); + it('should validate `entry.operator` accepts known values', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry({ operator: 'included' })], + }); + expect(() => body.validate(bodyMsg)).not.toThrow(); }); it('should validate `entry.value` required', () => { - const { value, ...entry } = getTrustedAppItemEntryItem(); - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [entry], - }; - expect(() => body.validate(bodyMsg)).toThrow(); + const { value, ...entry } = createConditionEntry(); + expect(() => body.validate(createNewTrustedApp({ entries: [entry] }))).toThrow(); }); it('should validate `entry.value` is non-empty', () => { - const bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - value: '', - }, - ], - }; + const bodyMsg = createNewTrustedApp({ entries: [createConditionEntry({ value: '' })] }); expect(() => body.validate(bodyMsg)).toThrow(); }); - it('should validate that `entry.field` is used only once', () => { - let bodyMsg = { - ...getCreateTrustedAppItem(), - entries: [getTrustedAppItemEntryItem(), getTrustedAppItemEntryItem()], - }; + it('should validate that `entry.field` path field value can only be used once', () => { + const bodyMsg = createNewTrustedApp({ + entries: [createConditionEntry(), createConditionEntry()], + }); expect(() => body.validate(bodyMsg)).toThrow('[Path] field can only be used once'); + }); - bodyMsg = { - ...getCreateTrustedAppItem(), + it('should validate that `entry.field` hash field value can only be used once', () => { + const bodyMsg = createNewTrustedApp({ entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', + createConditionEntry({ + field: ConditionEntryField.HASH, value: VALID_HASH_MD5, - }, - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', + }), + createConditionEntry({ + field: ConditionEntryField.HASH, value: VALID_HASH_MD5, - }, + }), ], - }; + }); expect(() => body.validate(bodyMsg)).toThrow('[Hash] field can only be used once'); }); + it('should validate that `entry.field` signer field value can only be used once', () => { + const bodyMsg = createNewTrustedApp({ + entries: [ + createConditionEntry({ + field: ConditionEntryField.SIGNER, + value: 'Microsoft', + }), + createConditionEntry({ + field: ConditionEntryField.SIGNER, + value: 'Microsoft', + }), + ], + }); + expect(() => body.validate(bodyMsg)).toThrow('[Signer] field can only be used once'); + }); + it('should validate Hash field valid value', () => { [VALID_HASH_MD5, VALID_HASH_SHA1, VALID_HASH_SHA256].forEach((value) => { expect(() => { - body.validate({ - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', - value, - }, - ], - }); + body.validate( + createNewTrustedApp({ + entries: [createConditionEntry({ field: ConditionEntryField.HASH, value })], + }) + ); }).not.toThrow(); }); }); @@ -337,49 +299,29 @@ describe('When invoking Trusted Apps Schema', () => { it('should validate Hash value with invalid length', () => { ['xyz', VALID_HASH_SHA256 + VALID_HASH_MD5].forEach((value) => { expect(() => { - body.validate({ - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', - value, - }, - ], - }); + body.validate( + createNewTrustedApp({ + entries: [createConditionEntry({ field: ConditionEntryField.HASH, value })], + }) + ); }).toThrow(); }); }); it('should validate Hash value with invalid characters', () => { expect(() => { - body.validate({ - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', - value: `G${VALID_HASH_MD5.substr(1)}`, - }, - ], - }); + body.validate( + createNewTrustedApp({ + entries: [ + createConditionEntry({ + field: ConditionEntryField.HASH, + value: `G${VALID_HASH_MD5.substr(1)}`, + }), + ], + }) + ); }).toThrow(); }); - - it('should trim hash value before validation', () => { - expect(() => { - body.validate({ - ...getCreateTrustedAppItem(), - entries: [ - { - ...getTrustedAppItemEntryItem(), - field: 'process.hash.*', - value: ` ${VALID_HASH_MD5} \r\n`, - }, - ], - }); - }).not.toThrow(); - }); }); }); }); diff --git a/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.ts b/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.ts index 74135169635bd..fee35e8f487a5 100644 --- a/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.ts +++ b/x-pack/plugins/security_solution/common/endpoint/schema/trusted_apps.ts @@ -4,22 +4,25 @@ * you may not use this file except in compliance with the Elastic License. */ -import { schema } from '@kbn/config-schema'; -import { TrustedApp } from '../types'; +import { schema, Type } from '@kbn/config-schema'; +import { ConditionEntry, ConditionEntryField, OperatingSystem } from '../types'; -const hashLengths: readonly number[] = [ +const HASH_LENGTHS: readonly number[] = [ 32, // MD5 40, // SHA1 64, // SHA256 ]; -const hasInvalidCharacters = /[^0-9a-f]/i; +const INVALID_CHARACTERS_PATTERN = /[^0-9a-f]/i; -const entryFieldLabels: { [k in TrustedApp['entries'][0]['field']]: string } = { - 'process.hash.*': 'Hash', - 'process.executable.caseless': 'Path', - 'process.code_signature': 'Signer', +const entryFieldLabels: { [k in ConditionEntryField]: string } = { + [ConditionEntryField.HASH]: 'Hash', + [ConditionEntryField.PATH]: 'Path', + [ConditionEntryField.SIGNER]: 'Signer', }; +const isValidHash = (value: string) => + HASH_LENGTHS.includes(value.length) && !INVALID_CHARACTERS_PATTERN.test(value); + export const DeleteTrustedAppsRequestSchema = { params: schema.object({ id: schema.string(), @@ -33,17 +36,17 @@ export const GetTrustedAppsRequestSchema = { }), }; -export const PostTrustedAppCreateRequestSchema = { - body: schema.object({ +const createNewTrustedAppForOsScheme = ( + osSchema: Type, + fieldSchema: Type +) => + schema.object({ name: schema.string({ minLength: 1, maxLength: 256 }), description: schema.maybe(schema.string({ minLength: 0, maxLength: 256, defaultValue: '' })), - os: schema.oneOf([schema.literal('linux'), schema.literal('macos'), schema.literal('windows')]), + os: osSchema, entries: schema.arrayOf( schema.object({ - field: schema.oneOf([ - schema.literal('process.hash.*'), - schema.literal('process.executable.caseless'), - ]), + field: fieldSchema, type: schema.literal('match'), operator: schema.literal('included'), value: schema.string({ minLength: 1 }), @@ -51,27 +54,43 @@ export const PostTrustedAppCreateRequestSchema = { { minSize: 1, validate(entries) { - const usedFields: string[] = []; - for (const { field, value } of entries) { - if (usedFields.includes(field)) { + const usedFields = new Set(); + + for (const entry of entries) { + // unfortunately combination of generics and Type<...> for "field" causes type errors + const { field, value } = entry as ConditionEntry; + + if (usedFields.has(field)) { return `[${entryFieldLabels[field]}] field can only be used once`; } - usedFields.push(field); - - if (field === 'process.hash.*') { - const trimmedValue = value.trim(); + usedFields.add(field); - if ( - !hashLengths.includes(trimmedValue.length) || - hasInvalidCharacters.test(trimmedValue) - ) { - return `Invalid hash value [${value}]`; - } + if (field === ConditionEntryField.HASH && !isValidHash(value)) { + return `Invalid hash value [${value}]`; } } }, } ), - }), + }); + +export const PostTrustedAppCreateRequestSchema = { + body: schema.oneOf([ + createNewTrustedAppForOsScheme( + schema.oneOf([schema.literal(OperatingSystem.LINUX), schema.literal(OperatingSystem.MAC)]), + schema.oneOf([ + schema.literal(ConditionEntryField.HASH), + schema.literal(ConditionEntryField.PATH), + ]) + ), + createNewTrustedAppForOsScheme( + schema.literal(OperatingSystem.WINDOWS), + schema.oneOf([ + schema.literal(ConditionEntryField.HASH), + schema.literal(ConditionEntryField.PATH), + schema.literal(ConditionEntryField.SIGNER), + ]) + ), + ]), }; diff --git a/x-pack/plugins/security_solution/common/endpoint/types/os.ts b/x-pack/plugins/security_solution/common/endpoint/types/os.ts index b9afbd63ecd54..df6ff4c3cd8dc 100644 --- a/x-pack/plugins/security_solution/common/endpoint/types/os.ts +++ b/x-pack/plugins/security_solution/common/endpoint/types/os.ts @@ -4,7 +4,8 @@ * you may not use this file except in compliance with the Elastic License. */ -export type Linux = 'linux'; -export type MacOS = 'macos'; -export type Windows = 'windows'; -export type OperatingSystem = Linux | MacOS | Windows; +export enum OperatingSystem { + LINUX = 'linux', + MAC = 'macos', + WINDOWS = 'windows', +} diff --git a/x-pack/plugins/security_solution/common/endpoint/types/trusted_apps.ts b/x-pack/plugins/security_solution/common/endpoint/types/trusted_apps.ts index 79d66443bc8f1..57e7ffff08051 100644 --- a/x-pack/plugins/security_solution/common/endpoint/types/trusted_apps.ts +++ b/x-pack/plugins/security_solution/common/endpoint/types/trusted_apps.ts @@ -11,7 +11,7 @@ import { GetTrustedAppsRequestSchema, PostTrustedAppCreateRequestSchema, } from '../schema/trusted_apps'; -import { Linux, MacOS, Windows } from './os'; +import { OperatingSystem } from './os'; /** API request params for deleting Trusted App entry */ export type DeleteTrustedAppsRequestParams = TypeOf; @@ -33,33 +33,41 @@ export interface PostTrustedAppCreateResponse { data: TrustedApp; } -export interface MacosLinuxConditionEntry { - field: 'process.hash.*' | 'process.executable.caseless'; +export enum ConditionEntryField { + HASH = 'process.hash.*', + PATH = 'process.executable.caseless', + SIGNER = 'process.Ext.code_signature', +} + +export interface ConditionEntry { + field: T; type: 'match'; operator: 'included'; value: string; } -export type WindowsConditionEntry = - | MacosLinuxConditionEntry - | (Omit & { - field: 'process.code_signature'; - }); +export type MacosLinuxConditionEntry = ConditionEntry< + ConditionEntryField.HASH | ConditionEntryField.PATH +>; +export type WindowsConditionEntry = ConditionEntry< + ConditionEntryField.HASH | ConditionEntryField.PATH | ConditionEntryField.SIGNER +>; + +export interface MacosLinuxConditionEntries { + os: OperatingSystem.LINUX | OperatingSystem.MAC; + entries: MacosLinuxConditionEntry[]; +} + +export interface WindowsConditionEntries { + os: OperatingSystem.WINDOWS; + entries: WindowsConditionEntry[]; +} /** Type for a new Trusted App Entry */ export type NewTrustedApp = { name: string; description?: string; -} & ( - | { - os: Linux | MacOS; - entries: MacosLinuxConditionEntry[]; - } - | { - os: Windows; - entries: WindowsConditionEntry[]; - } -); +} & (MacosLinuxConditionEntries | WindowsConditionEntries); /** A trusted app entry */ export type TrustedApp = NewTrustedApp & { diff --git a/x-pack/plugins/security_solution/public/common/mock/endpoint/dependencies_start_mock.ts b/x-pack/plugins/security_solution/public/common/mock/endpoint/dependencies_start_mock.ts index 864b5e9df8043..5a8be7dfa77da 100644 --- a/x-pack/plugins/security_solution/public/common/mock/endpoint/dependencies_start_mock.ts +++ b/x-pack/plugins/security_solution/public/common/mock/endpoint/dependencies_start_mock.ts @@ -9,6 +9,7 @@ import { dataPluginMock, Start as DataPublicStartMock, } from '../../../../../../../src/plugins/data/public/mocks'; +import { fleetMock } from '../../../../../fleet/public/mocks'; type DataMock = Omit & { indexPatterns: Omit & { @@ -56,9 +57,6 @@ export const depsStartMock: () => DepsStartMock = () => { return { data: dataMock, - fleet: { - isInitialized: () => Promise.resolve(true), - registerExtension: jest.fn(), - }, + fleet: fleetMock.createStartMock(), }; }; diff --git a/x-pack/plugins/security_solution/public/management/common/translations.ts b/x-pack/plugins/security_solution/public/management/common/translations.ts index 415658c1fd6af..a2454bb0ec282 100644 --- a/x-pack/plugins/security_solution/public/management/common/translations.ts +++ b/x-pack/plugins/security_solution/public/management/common/translations.ts @@ -25,13 +25,13 @@ export const BETA_BADGE_LABEL = i18n.translate('xpack.securitySolution.administr }); export const OS_TITLES: Readonly<{ [K in OperatingSystem]: string }> = { - windows: i18n.translate('xpack.securitySolution.administration.os.windows', { + [OperatingSystem.WINDOWS]: i18n.translate('xpack.securitySolution.administration.os.windows', { defaultMessage: 'Windows', }), - macos: i18n.translate('xpack.securitySolution.administration.os.macos', { + [OperatingSystem.MAC]: i18n.translate('xpack.securitySolution.administration.os.macos', { defaultMessage: 'Mac', }), - linux: i18n.translate('xpack.securitySolution.administration.os.linux', { + [OperatingSystem.LINUX]: i18n.translate('xpack.securitySolution.administration.os.linux', { defaultMessage: 'Linux', }), }; diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/components/config_form/index.stories.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/components/config_form/index.stories.tsx index 4f288af393b7c..dcd2bdac281e9 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/components/config_form/index.stories.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/components/config_form/index.stories.tsx @@ -5,10 +5,12 @@ */ import React from 'react'; import { ThemeProvider } from 'styled-components'; -import { storiesOf, addDecorator } from '@storybook/react'; +import { addDecorator, storiesOf } from '@storybook/react'; import euiLightVars from '@elastic/eui/dist/eui_theme_light.json'; import { EuiCheckbox, EuiSpacer, EuiSwitch, EuiText } from '@elastic/eui'; +import { OperatingSystem } from '../../../../../../../common/endpoint/types'; + import { ConfigForm } from '.'; addDecorator((storyFn) => ( @@ -18,21 +20,24 @@ addDecorator((storyFn) => ( storiesOf('PolicyDetails/ConfigForm', module) .add('One OS', () => { return ( - + {'Some content'} ); }) .add('Multiple OSs', () => { return ( - + {'Some content'} ); }) .add('Complex content', () => { return ( - + {'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore ' + 'et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut ' + @@ -53,7 +58,7 @@ storiesOf('PolicyDetails/ConfigForm', module) const toggle = {}} />; return ( - + {'Some content'} ); diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/antivirus_registration/index.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/antivirus_registration/index.tsx index 8d1ac29c8ce1e..21fe14df81dd2 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/antivirus_registration/index.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/antivirus_registration/index.tsx @@ -9,6 +9,7 @@ import { useDispatch } from 'react-redux'; import { i18n } from '@kbn/i18n'; import { EuiSpacer, EuiSwitch, EuiText } from '@elastic/eui'; +import { OperatingSystem } from '../../../../../../../common/endpoint/types'; import { isAntivirusRegistrationEnabled } from '../../../store/policy_details/selectors'; import { usePolicyDetailsSelector } from '../../policy_hooks'; import { ConfigForm } from '../../components/config_form'; @@ -36,7 +37,7 @@ export const AntivirusRegistrationForm = memo(() => { defaultMessage: 'Register as anti-virus', } )} - supportedOss={['windows']} + supportedOss={[OperatingSystem.WINDOWS]} > {i18n.translate( diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/linux.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/linux.tsx index b43f93f1a1e2b..999e3bac5653a 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/linux.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/linux.tsx @@ -6,14 +6,14 @@ import React, { useMemo } from 'react'; import { i18n } from '@kbn/i18n'; -import { EuiText, EuiSpacer } from '@elastic/eui'; +import { EuiSpacer, EuiText } from '@elastic/eui'; import { EventsCheckbox } from './checkbox'; import { OS } from '../../../types'; import { usePolicyDetailsSelector } from '../../policy_hooks'; import { selectedLinuxEvents, totalLinuxEvents } from '../../../store/policy_details/selectors'; import { ConfigForm, ConfigFormHeading } from '../../components/config_form'; import { getIn, setIn } from '../../../models/policy_details_config'; -import { UIPolicyConfig } from '../../../../../../../common/endpoint/types'; +import { OperatingSystem, UIPolicyConfig } from '../../../../../../../common/endpoint/types'; import { COLLECTIONS_ENABLED_MESSAGE, EVENTS_FORM_TYPE_LABEL, @@ -85,7 +85,7 @@ export const LinuxEvents = React.memo(() => { return ( diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/mac.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/mac.tsx index fbbe50fbec1b0..6e15a3c4cd43b 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/mac.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/mac.tsx @@ -6,14 +6,14 @@ import React, { useMemo } from 'react'; import { i18n } from '@kbn/i18n'; -import { EuiText, EuiSpacer } from '@elastic/eui'; +import { EuiSpacer, EuiText } from '@elastic/eui'; import { EventsCheckbox } from './checkbox'; import { OS } from '../../../types'; import { usePolicyDetailsSelector } from '../../policy_hooks'; import { selectedMacEvents, totalMacEvents } from '../../../store/policy_details/selectors'; import { ConfigForm, ConfigFormHeading } from '../../components/config_form'; import { getIn, setIn } from '../../../models/policy_details_config'; -import { UIPolicyConfig } from '../../../../../../../common/endpoint/types'; +import { OperatingSystem, UIPolicyConfig } from '../../../../../../../common/endpoint/types'; import { COLLECTIONS_ENABLED_MESSAGE, EVENTS_FORM_TYPE_LABEL, @@ -85,7 +85,7 @@ export const MacEvents = React.memo(() => { return ( diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/windows.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/windows.tsx index cd2ef62c1cb84..c381249cf24b9 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/windows.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/events/windows.tsx @@ -6,14 +6,18 @@ import React, { useMemo } from 'react'; import { i18n } from '@kbn/i18n'; -import { EuiText, EuiSpacer } from '@elastic/eui'; +import { EuiSpacer, EuiText } from '@elastic/eui'; import { EventsCheckbox } from './checkbox'; import { OS } from '../../../types'; import { usePolicyDetailsSelector } from '../../policy_hooks'; import { selectedWindowsEvents, totalWindowsEvents } from '../../../store/policy_details/selectors'; import { ConfigForm, ConfigFormHeading } from '../../components/config_form'; -import { setIn, getIn } from '../../../models/policy_details_config'; -import { UIPolicyConfig, Immutable } from '../../../../../../../common/endpoint/types'; +import { getIn, setIn } from '../../../models/policy_details_config'; +import { + Immutable, + OperatingSystem, + UIPolicyConfig, +} from '../../../../../../../common/endpoint/types'; import { COLLECTIONS_ENABLED_MESSAGE, EVENTS_FORM_TYPE_LABEL, @@ -127,7 +131,7 @@ export const WindowsEvents = React.memo(() => { return ( diff --git a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/protections/malware.tsx b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/protections/malware.tsx index c5724956bc21f..c78455aa8d990 100644 --- a/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/protections/malware.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/policy/view/policy_forms/protections/malware.tsx @@ -10,21 +10,25 @@ import styled from 'styled-components'; import { i18n } from '@kbn/i18n'; import { FormattedMessage } from '@kbn/i18n/react'; import { + EuiCallOut, + EuiCheckbox, EuiRadio, + EuiSpacer, EuiSwitch, EuiText, - EuiSpacer, EuiTextArea, htmlIdGenerator, - EuiCallOut, - EuiCheckbox, } from '@elastic/eui'; import { cloneDeep } from 'lodash'; import { APP_ID } from '../../../../../../../common/constants'; import { SecurityPageName } from '../../../../../../app/types'; -import { Immutable, ProtectionModes } from '../../../../../../../common/endpoint/types'; -import { OS, MalwareProtectionOSes } from '../../../types'; +import { + Immutable, + OperatingSystem, + ProtectionModes, +} from '../../../../../../../common/endpoint/types'; +import { MalwareProtectionOSes, OS } from '../../../types'; import { ConfigForm, ConfigFormHeading } from '../../components/config_form'; import { policyConfig } from '../../../store/policy_details/selectors'; import { usePolicyDetailsSelector } from '../../policy_hooks'; @@ -305,7 +309,7 @@ export const MalwareProtections = React.memo(() => { type={i18n.translate('xpack.securitySolution.endpoint.policy.details.malware', { defaultMessage: 'Malware', })} - supportedOss={['windows', 'macos']} + supportedOss={[OperatingSystem.WINDOWS, OperatingSystem.MAC]} dataTestSubj="malwareProtectionsForm" rightCorner={protectionSwitch} > diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/type_guards.ts b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/type_guards.ts index 23b13695b0595..fe2ab98edb588 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/type_guards.ts +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/state/type_guards.ts @@ -11,12 +11,12 @@ import { TrustedAppCreateSuccess, } from './trusted_apps_list_page_state'; import { + ConditionEntry, + ConditionEntryField, Immutable, MacosLinuxConditionEntry, - NewTrustedApp, WindowsConditionEntry, } from '../../../../../common/endpoint/types'; -import { TRUSTED_APPS_SUPPORTED_OS_TYPES } from '../../../../../common/endpoint/constants'; type CreateViewPossibleStates = | TrustedAppsListPageState['createView'] @@ -40,23 +40,14 @@ export const isTrustedAppCreateFailureState = ( return data?.type === 'failure'; }; -export const isWindowsTrustedApp = ( - trustedApp: T -): trustedApp is T & { os: 'windows' } => { - return trustedApp.os === 'windows'; +export const isWindowsTrustedAppCondition = ( + condition: ConditionEntry +): condition is WindowsConditionEntry => { + return condition.field === ConditionEntryField.SIGNER || true; }; -export const isWindowsTrustedAppCondition = (condition: { - field: string; -}): condition is WindowsConditionEntry => { - return condition.field === 'process.code_signature' || true; +export const isMacosLinuxTrustedAppCondition = ( + condition: ConditionEntry +): condition is MacosLinuxConditionEntry => { + return condition.field !== ConditionEntryField.SIGNER; }; - -export const isMacosLinuxTrustedAppCondition = (condition: { - field: string; -}): condition is MacosLinuxConditionEntry => { - return condition.field !== 'process.code_signature' || true; -}; - -export const isTrustedAppSupportedOs = (os: string): os is NewTrustedApp['os'] => - TRUSTED_APPS_SUPPORTED_OS_TYPES.includes(os); diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/test_utils/index.ts b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/test_utils/index.ts index d881b5cbcb5b0..66674c3665ce3 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/test_utils/index.ts +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/test_utils/index.ts @@ -5,7 +5,7 @@ */ import { combineReducers, createStore } from 'redux'; -import { TrustedApp } from '../../../../../common/endpoint/types'; +import { TrustedApp, OperatingSystem } from '../../../../../common/endpoint/types'; import { RoutingAction } from '../../../../common/store/routing'; import { @@ -31,7 +31,11 @@ import { import { trustedAppsPageReducer } from '../store/reducer'; import { TrustedAppsListResourceStateChanged } from '../store/action'; -const OS_LIST: Array = ['windows', 'macos', 'linux']; +const OPERATING_SYSTEMS: OperatingSystem[] = [ + OperatingSystem.WINDOWS, + OperatingSystem.MAC, + OperatingSystem.LINUX, +]; const generate = (count: number, generator: (i: number) => T) => [...new Array(count).keys()].map(generator); @@ -43,7 +47,7 @@ export const createSampleTrustedApp = (i: number, longTexts?: boolean): TrustedA description: generate(longTexts ? 10 : 1, () => `Trusted App ${i}`).join(' '), created_at: '1 minute ago', created_by: 'someone', - os: OS_LIST[i % 3], + os: OPERATING_SYSTEMS[i % 3], entries: [], }; }; diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.test.tsx b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.test.tsx index 4bac9164e1d62..56c1b3af77aa5 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.test.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.test.tsx @@ -4,14 +4,17 @@ * you may not use this file except in compliance with the Elastic License. */ +import React from 'react'; +import * as reactTestingLibrary from '@testing-library/react'; +import { fireEvent, getByTestId } from '@testing-library/dom'; + +import { ConditionEntryField, OperatingSystem } from '../../../../../../common/endpoint/types'; import { AppContextTestRender, createAppRootMockRenderer, } from '../../../../../common/mock/endpoint'; -import * as reactTestingLibrary from '@testing-library/react'; -import React from 'react'; + import { CreateTrustedAppForm, CreateTrustedAppFormProps } from './create_trusted_app_form'; -import { fireEvent, getByTestId } from '@testing-library/dom'; describe('When showing the Trusted App Create Form', () => { const dataTestSubjForForm = 'createForm'; @@ -234,14 +237,14 @@ describe('When showing the Trusted App Create Form', () => { description: '', entries: [ { - field: 'process.hash.*', + field: ConditionEntryField.HASH, operator: 'included', type: 'match', value: '', }, ], name: '', - os: 'windows', + os: OperatingSystem.WINDOWS, }, }); }); @@ -289,14 +292,14 @@ describe('When showing the Trusted App Create Form', () => { description: 'some description', entries: [ { - field: 'process.hash.*', + field: ConditionEntryField.HASH, operator: 'included', type: 'match', value: 'someHASH', }, ], name: 'Some Process', - os: 'windows', + os: OperatingSystem.WINDOWS, }, }); }); diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.tsx b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.tsx index b8692df0240fa..0a449bba7ca43 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/create_trusted_app_form.tsx @@ -6,34 +6,39 @@ import React, { ChangeEventHandler, memo, useCallback, useEffect, useMemo, useState } from 'react'; import { + EuiFieldText, EuiForm, EuiFormRow, - EuiFieldText, EuiSuperSelect, EuiSuperSelectOption, EuiTextArea, } from '@elastic/eui'; import { i18n } from '@kbn/i18n'; import { EuiFormProps } from '@elastic/eui/src/components/form/form'; -import { TRUSTED_APPS_SUPPORTED_OS_TYPES } from '../../../../../../common/endpoint/constants'; import { LogicalConditionBuilder } from './logical_condition'; import { + ConditionEntry, + ConditionEntryField, MacosLinuxConditionEntry, NewTrustedApp, - TrustedApp, + OperatingSystem, } from '../../../../../../common/endpoint/types'; import { LogicalConditionBuilderProps } from './logical_condition/logical_condition_builder'; import { OS_TITLES } from '../translations'; import { isMacosLinuxTrustedAppCondition, - isTrustedAppSupportedOs, - isWindowsTrustedApp, isWindowsTrustedAppCondition, } from '../../state/type_guards'; -const generateNewEntry = (): NewTrustedApp['entries'][0] => { +const OPERATING_SYSTEMS: readonly OperatingSystem[] = [ + OperatingSystem.MAC, + OperatingSystem.WINDOWS, + OperatingSystem.LINUX, +]; + +const generateNewEntry = (): ConditionEntry => { return { - field: 'process.hash.*', + field: ConditionEntryField.HASH, operator: 'included', type: 'match', value: '', @@ -160,18 +165,14 @@ export const CreateTrustedAppForm = memo( ({ fullWidth, onChange, ...formProps }) => { const dataTestSubj = formProps['data-test-subj']; - const osOptions: Array> = useMemo(() => { - return TRUSTED_APPS_SUPPORTED_OS_TYPES.map((os) => { - return { - value: os, - inputDisplay: OS_TITLES[os as TrustedApp['os']], - }; - }); - }, []); + const osOptions: Array> = useMemo( + () => OPERATING_SYSTEMS.map((os) => ({ value: os, inputDisplay: OS_TITLES[os] })), + [] + ); const [formValues, setFormValues] = useState({ name: '', - os: 'windows', + os: OperatingSystem.WINDOWS, entries: [generateNewEntry()], description: '', }); @@ -200,20 +201,20 @@ export const CreateTrustedAppForm = memo( const handleAndClick = useCallback(() => { setFormValues( (prevState): NewTrustedApp => { - if (isWindowsTrustedApp(prevState)) { + if (prevState.os === OperatingSystem.WINDOWS) { return { ...prevState, - entries: [...prevState.entries, generateNewEntry()].filter((entry) => - isWindowsTrustedAppCondition(entry) + entries: [...prevState.entries, generateNewEntry()].filter( + isWindowsTrustedAppCondition ), }; } else { return { ...prevState, entries: [ - ...prevState.entries.filter((entry) => isMacosLinuxTrustedAppCondition(entry)), + ...prevState.entries.filter(isMacosLinuxTrustedAppCondition), generateNewEntry(), - ] as MacosLinuxConditionEntry[], + ], }; } } @@ -245,30 +246,27 @@ export const CreateTrustedAppForm = memo( [] ); - const handleOsChange = useCallback<(v: string) => void>((newOsValue) => { + const handleOsChange = useCallback<(v: OperatingSystem) => void>((newOsValue) => { setFormValues( (prevState): NewTrustedApp => { - if (isTrustedAppSupportedOs(newOsValue)) { - const updatedState: NewTrustedApp = { - ...prevState, - entries: [], - os: newOsValue, - }; - if (!isWindowsTrustedApp(updatedState)) { - updatedState.entries.push( - ...(prevState.entries.filter((entry) => - isMacosLinuxTrustedAppCondition(entry) - ) as MacosLinuxConditionEntry[]) - ); - if (updatedState.entries.length === 0) { - updatedState.entries.push(generateNewEntry() as MacosLinuxConditionEntry); - } - } else { - updatedState.entries.push(...prevState.entries); + const updatedState: NewTrustedApp = { + ...prevState, + entries: [], + os: newOsValue, + }; + if (updatedState.os !== OperatingSystem.WINDOWS) { + updatedState.entries.push( + ...(prevState.entries.filter((entry) => + isMacosLinuxTrustedAppCondition(entry) + ) as MacosLinuxConditionEntry[]) + ); + if (updatedState.entries.length === 0) { + updatedState.entries.push(generateNewEntry()); } - return updatedState; + } else { + updatedState.entries.push(...prevState.entries); } - return prevState; + return updatedState; } ); setWasVisited((prevState) => { @@ -294,7 +292,7 @@ export const CreateTrustedAppForm = memo( (newEntry, oldEntry) => { setFormValues( (prevState): NewTrustedApp => { - if (isWindowsTrustedApp(prevState)) { + if (prevState.os === OperatingSystem.WINDOWS) { return { ...prevState, entries: prevState.entries.map((item) => { diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_entry.tsx b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_entry.tsx index 020ab3f1cf1fd..df85244cd2813 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_entry.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_entry.tsx @@ -5,6 +5,7 @@ */ import React, { ChangeEventHandler, memo, useCallback, useMemo } from 'react'; +import { i18n } from '@kbn/i18n'; import { EuiFlexGroup, EuiFlexItem, @@ -14,8 +15,8 @@ import { EuiButtonIcon, EuiSuperSelectOption, } from '@elastic/eui'; -import { i18n } from '@kbn/i18n'; -import { TrustedApp } from '../../../../../../../../common/endpoint/types'; + +import { ConditionEntryField, TrustedApp } from '../../../../../../../../common/endpoint/types'; import { CONDITION_FIELD_TITLE } from '../../../translations'; const ConditionEntryCell = memo<{ @@ -73,12 +74,12 @@ export const ConditionEntry = memo( const fieldOptions = useMemo>>(() => { return [ { - inputDisplay: CONDITION_FIELD_TITLE['process.hash.*'], - value: 'process.hash.*', + inputDisplay: CONDITION_FIELD_TITLE[ConditionEntryField.HASH], + value: ConditionEntryField.HASH, }, { - inputDisplay: CONDITION_FIELD_TITLE['process.executable.caseless'], - value: 'process.executable.caseless', + inputDisplay: CONDITION_FIELD_TITLE[ConditionEntryField.PATH], + value: ConditionEntryField.PATH, }, ]; }, []); diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_group.tsx b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_group.tsx index 5c8a55653a84f..9b961d87b7eb1 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_group.tsx +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/components/logical_condition/components/condition_group.tsx @@ -8,7 +8,7 @@ import React, { memo, useCallback } from 'react'; import { EuiButton, EuiFlexGroup, EuiFlexItem, EuiHideFor, EuiSpacer } from '@elastic/eui'; import styled from 'styled-components'; import { FormattedMessage } from '@kbn/i18n/react'; -import { NewTrustedApp, TrustedApp } from '../../../../../../../../common/endpoint/types'; +import { TrustedApp, WindowsConditionEntry } from '../../../../../../../../common/endpoint/types'; import { ConditionEntry, ConditionEntryProps } from './condition_entry'; import { AndOrBadge } from '../../../../../../../common/components/and_or_badge'; @@ -85,7 +85,7 @@ export const ConditionGroup = memo( )}
- {(entries as (NewTrustedApp & { os: 'windows' })['entries']).map((entry, index) => ( + {(entries as WindowsConditionEntry[]).map((entry, index) => ( ( )); const PATH_CONDITION: WindowsConditionEntry = { - field: 'process.executable.caseless', + field: ConditionEntryField.PATH, operator: 'included', type: 'match', value: '/some/path/on/file/system', }; const SIGNER_CONDITION: WindowsConditionEntry = { - field: 'process.code_signature', + field: ConditionEntryField.SIGNER, operator: 'included', type: 'match', value: 'Elastic', diff --git a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/translations.ts b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/translations.ts index 4c2b3f0e59ccb..4e31890da84d0 100644 --- a/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/translations.ts +++ b/x-pack/plugins/security_solution/public/management/pages/trusted_apps/view/translations.ts @@ -9,33 +9,34 @@ import { TrustedApp, MacosLinuxConditionEntry, WindowsConditionEntry, + ConditionEntry, + ConditionEntryField, } from '../../../../../common/endpoint/types'; export { OS_TITLES } from '../../../common/translations'; export const ABOUT_TRUSTED_APPS = i18n.translate('xpack.securitySolution.trustedapps.aboutInfo', { defaultMessage: - 'Add a trusted application to improve performance or alleviate conflicts with other applications running on your hosts. Trusted applications will be applied to hosts running Endpoint Security.', + 'Add a trusted application to improve performance or alleviate conflicts with other applications ' + + 'running on your hosts. Trusted applications will be applied to hosts running Endpoint Security.', }); -type Entry = MacosLinuxConditionEntry | WindowsConditionEntry; - -export const CONDITION_FIELD_TITLE: { [K in Entry['field']]: string } = { - 'process.hash.*': i18n.translate( +export const CONDITION_FIELD_TITLE: { [K in ConditionEntryField]: string } = { + [ConditionEntryField.HASH]: i18n.translate( 'xpack.securitySolution.trustedapps.logicalConditionBuilder.entry.field.hash', { defaultMessage: 'Hash' } ), - 'process.executable.caseless': i18n.translate( + [ConditionEntryField.PATH]: i18n.translate( 'xpack.securitySolution.trustedapps.logicalConditionBuilder.entry.field.path', { defaultMessage: 'Path' } ), - 'process.code_signature': i18n.translate( + [ConditionEntryField.SIGNER]: i18n.translate( 'xpack.securitySolution.trustedapps.logicalConditionBuilder.entry.field.signature', { defaultMessage: 'Signature' } ), }; -export const OPERATOR_TITLE: { [K in Entry['operator']]: string } = { +export const OPERATOR_TITLE: { [K in ConditionEntry['operator']]: string } = { included: i18n.translate('xpack.securitySolution.trustedapps.card.operator.includes', { defaultMessage: 'is', }), diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.test.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.test.ts new file mode 100644 index 0000000000000..e87a8ada6bf2b --- /dev/null +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.test.ts @@ -0,0 +1,233 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { KibanaResponseFactory } from 'kibana/server'; + +import { xpackMocks } from '../../../../../../mocks'; +import { loggingSystemMock, httpServerMock } from '../../../../../../../src/core/server/mocks'; +import { ExceptionListItemSchema } from '../../../../../lists/common/schemas/response'; +import { listMock } from '../../../../../lists/server/mocks'; +import { ExceptionListClient } from '../../../../../lists/server'; +import { createMockConfig } from '../../../lib/detection_engine/routes/__mocks__'; + +import { ConditionEntryField, OperatingSystem } from '../../../../common/endpoint/types'; +import { EndpointAppContextService } from '../../endpoint_app_context_services'; +import { createConditionEntry, createEntryMatch } from './mapping'; +import { + getTrustedAppsCreateRouteHandler, + getTrustedAppsDeleteRouteHandler, + getTrustedAppsListRouteHandler, +} from './handlers'; + +const exceptionsListClient = listMock.getExceptionListClient() as jest.Mocked; + +const createAppContextMock = () => ({ + logFactory: loggingSystemMock.create(), + service: new EndpointAppContextService(), + config: () => Promise.resolve(createMockConfig()), +}); + +const createHandlerContextMock = () => ({ + ...xpackMocks.createRequestHandlerContext(), + lists: { + getListClient: jest.fn(), + getExceptionListClient: jest.fn().mockReturnValue(exceptionsListClient), + }, +}); + +const assertResponse = ( + response: jest.Mocked, + expectedResponseType: keyof KibanaResponseFactory, + expectedResponseBody: T +) => { + expect(response[expectedResponseType]).toBeCalled(); + expect(response[expectedResponseType].mock.calls[0][0]?.body).toEqual(expectedResponseBody); +}; + +const EXCEPTION_LIST_ITEM: ExceptionListItemSchema = { + _version: '123', + id: '123', + comments: [], + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + description: 'Linux trusted app 1', + entries: [ + createEntryMatch('process.executable.caseless', '/bin/malware'), + createEntryMatch('process.hash.md5', '1234234659af249ddf3e40864e9fb241'), + ], + item_id: '123', + list_id: 'endpoint_trusted_apps', + meta: undefined, + name: 'linux trusted app 1', + namespace_type: 'agnostic', + os_types: ['linux'], + tags: [], + type: 'simple', + tie_breaker_id: '123', + updated_at: '11/11/2011T11:11:11.111', + updated_by: 'admin', +}; + +const NEW_TRUSTED_APP = { + name: 'linux trusted app 1', + description: 'Linux trusted app 1', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.PATH, '/bin/malware'), + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + ], +}; + +const TRUSTED_APP = { + id: '123', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + name: 'linux trusted app 1', + description: 'Linux trusted app 1', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + createConditionEntry(ConditionEntryField.PATH, '/bin/malware'), + ], +}; + +describe('handlers', () => { + const appContextMock = createAppContextMock(); + + beforeEach(() => { + exceptionsListClient.deleteExceptionListItem.mockReset(); + exceptionsListClient.createExceptionListItem.mockReset(); + exceptionsListClient.findExceptionListItem.mockReset(); + exceptionsListClient.createTrustedAppsList.mockReset(); + + appContextMock.logFactory.get.mockClear(); + (appContextMock.logFactory.get().error as jest.Mock).mockClear(); + }); + + describe('getTrustedAppsDeleteRouteHandler', () => { + const deleteTrustedAppHandler = getTrustedAppsDeleteRouteHandler(appContextMock); + + it('should return ok when trusted app deleted', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + + exceptionsListClient.deleteExceptionListItem.mockResolvedValue(EXCEPTION_LIST_ITEM); + + await deleteTrustedAppHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ params: { id: '123' } }), + mockResponse + ); + + assertResponse(mockResponse, 'ok', undefined); + }); + + it('should return notFound when trusted app missing', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + + await deleteTrustedAppHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ params: { id: '123' } }), + mockResponse + ); + + assertResponse(mockResponse, 'notFound', 'trusted app id [123] not found'); + }); + + it('should return internalError when errors happen', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + const error = new Error('Something went wrong'); + + exceptionsListClient.deleteExceptionListItem.mockRejectedValue(error); + + await deleteTrustedAppHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ params: { id: '123' } }), + mockResponse + ); + + assertResponse(mockResponse, 'internalError', error); + expect(appContextMock.logFactory.get('trusted_apps').error).toHaveBeenCalledWith(error); + }); + }); + + describe('getTrustedAppsCreateRouteHandler', () => { + const createTrustedAppHandler = getTrustedAppsCreateRouteHandler(appContextMock); + + it('should return ok with body when trusted app created', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + + exceptionsListClient.createExceptionListItem.mockResolvedValue(EXCEPTION_LIST_ITEM); + + await createTrustedAppHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ body: NEW_TRUSTED_APP }), + mockResponse + ); + + assertResponse(mockResponse, 'ok', { data: TRUSTED_APP }); + }); + + it('should return internalError when errors happen', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + const error = new Error('Something went wrong'); + + exceptionsListClient.createExceptionListItem.mockRejectedValue(error); + + await createTrustedAppHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ body: NEW_TRUSTED_APP }), + mockResponse + ); + + assertResponse(mockResponse, 'internalError', error); + expect(appContextMock.logFactory.get('trusted_apps').error).toHaveBeenCalledWith(error); + }); + }); + + describe('getTrustedAppsListRouteHandler', () => { + const getTrustedAppsListHandler = getTrustedAppsListRouteHandler(appContextMock); + + it('should return ok with list when no errors', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + + exceptionsListClient.findExceptionListItem.mockResolvedValue({ + data: [EXCEPTION_LIST_ITEM], + page: 1, + per_page: 20, + total: 100, + }); + + await getTrustedAppsListHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ params: { page: 1, per_page: 20 } }), + mockResponse + ); + + assertResponse(mockResponse, 'ok', { + data: [TRUSTED_APP], + page: 1, + per_page: 20, + total: 100, + }); + }); + + it('should return internalError when errors happen', async () => { + const mockResponse = httpServerMock.createResponseFactory(); + const error = new Error('Something went wrong'); + + exceptionsListClient.findExceptionListItem.mockRejectedValue(error); + + await getTrustedAppsListHandler( + createHandlerContextMock(), + httpServerMock.createKibanaRequest({ body: NEW_TRUSTED_APP }), + mockResponse + ); + + assertResponse(mockResponse, 'internalError', error); + expect(appContextMock.logFactory.get('trusted_apps').error).toHaveBeenCalledWith(error); + }); + }); +}); diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.ts index 7cf3d467c10c2..36e253d9eb3b6 100644 --- a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.ts +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/handlers.ts @@ -5,16 +5,22 @@ */ import { RequestHandler, RequestHandlerContext } from 'kibana/server'; + +import { ExceptionListClient } from '../../../../../lists/server'; + import { DeleteTrustedAppsRequestParams, GetTrustedAppsListRequest, - GetTrustedListAppsResponse, PostTrustedAppCreateRequest, } from '../../../../common/endpoint/types'; + import { EndpointAppContext } from '../../types'; -import { exceptionItemToTrustedAppItem, newTrustedAppItemToExceptionItem } from './utils'; -import { ENDPOINT_TRUSTED_APPS_LIST_ID } from '../../../../../lists/common/constants'; -import { ExceptionListClient } from '../../../../../lists/server'; +import { + createTrustedApp, + deleteTrustedApp, + getTrustedAppsList, + MissingTrustedAppException, +} from './service'; const exceptionListClientFromContext = (context: RequestHandlerContext): ExceptionListClient => { const exceptionLists = context.lists?.getExceptionListClient(); @@ -33,22 +39,16 @@ export const getTrustedAppsDeleteRouteHandler = ( return async (context, req, res) => { try { - const exceptionsListService = exceptionListClientFromContext(context); - const { id } = req.params; - const response = await exceptionsListService.deleteExceptionListItem({ - id, - itemId: undefined, - namespaceType: 'agnostic', - }); - - if (response === null) { - return res.notFound({ body: `trusted app id [${id}] not found` }); - } + await deleteTrustedApp(exceptionListClientFromContext(context), req.params); return res.ok(); } catch (error) { - logger.error(error); - return res.internalError({ body: error }); + if (error instanceof MissingTrustedAppException) { + return res.notFound({ body: `trusted app id [${req.params.id}] not found` }); + } else { + logger.error(error); + return res.internalError({ body: error }); + } } }; }; @@ -59,28 +59,10 @@ export const getTrustedAppsListRouteHandler = ( const logger = endpointAppContext.logFactory.get('trusted_apps'); return async (context, req, res) => { - const { page, per_page: perPage } = req.query; - try { - const exceptionsListService = exceptionListClientFromContext(context); - // Ensure list is created if it does not exist - await exceptionsListService.createTrustedAppsList(); - const results = await exceptionsListService.findExceptionListItem({ - listId: ENDPOINT_TRUSTED_APPS_LIST_ID, - page, - perPage, - filter: undefined, - namespaceType: 'agnostic', - sortField: 'name', - sortOrder: 'asc', + return res.ok({ + body: await getTrustedAppsList(exceptionListClientFromContext(context), req.query), }); - const body: GetTrustedListAppsResponse = { - data: results?.data.map(exceptionItemToTrustedAppItem) ?? [], - total: results?.total ?? 0, - page: results?.page ?? 1, - per_page: results?.per_page ?? perPage!, - }; - return res.ok({ body }); } catch (error) { logger.error(error); return res.internalError({ body: error }); @@ -94,21 +76,9 @@ export const getTrustedAppsCreateRouteHandler = ( const logger = endpointAppContext.logFactory.get('trusted_apps'); return async (context, req, res) => { - const newTrustedApp = req.body; - try { - const exceptionsListService = exceptionListClientFromContext(context); - // Ensure list is created if it does not exist - await exceptionsListService.createTrustedAppsList(); - - const createdTrustedAppExceptionItem = await exceptionsListService.createExceptionListItem( - newTrustedAppItemToExceptionItem(newTrustedApp) - ); - return res.ok({ - body: { - data: exceptionItemToTrustedAppItem(createdTrustedAppExceptionItem), - }, + body: await createTrustedApp(exceptionListClientFromContext(context), req.body), }); } catch (error) { logger.error(error); diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.test.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.test.ts new file mode 100644 index 0000000000000..2fd972ee402e2 --- /dev/null +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.test.ts @@ -0,0 +1,425 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { CreateExceptionListItemOptions } from '../../../../../lists/server'; +import { ExceptionListItemSchema } from '../../../../../lists/common/schemas/response'; + +import { + ConditionEntryField, + NewTrustedApp, + OperatingSystem, + TrustedApp, +} from '../../../../common/endpoint/types'; + +import { + createConditionEntry, + createEntryMatch, + createEntryNested, + exceptionListItemToTrustedApp, + newTrustedAppToCreateExceptionListItemOptions, +} from './mapping'; + +const createExceptionListItemOptions = ( + options: Partial +): CreateExceptionListItemOptions => ({ + comments: [], + description: '', + entries: [], + itemId: expect.any(String), + listId: 'endpoint_trusted_apps', + meta: undefined, + name: '', + namespaceType: 'agnostic', + osTypes: [], + tags: [], + type: 'simple', + ...options, +}); + +const exceptionListItemSchema = ( + item: Partial +): ExceptionListItemSchema => ({ + _version: '123', + id: '', + comments: [], + created_at: '', + created_by: '', + description: '', + entries: [], + item_id: '123', + list_id: 'endpoint_trusted_apps', + meta: undefined, + name: '', + namespace_type: 'agnostic', + os_types: [], + tags: [], + type: 'simple', + tie_breaker_id: '123', + updated_at: '11/11/2011T11:11:11.111', + updated_by: 'admin', + ...(item || {}), +}); + +describe('mapping', () => { + describe('newTrustedAppToCreateExceptionListItemOptions', () => { + const testMapping = (input: NewTrustedApp, expectedResult: CreateExceptionListItemOptions) => { + expect(newTrustedAppToCreateExceptionListItemOptions(input)).toEqual(expectedResult); + }; + + it('should map linux trusted app condition properly', function () { + testMapping( + { + name: 'linux trusted app', + description: 'Linux Trusted App', + os: OperatingSystem.LINUX, + entries: [createConditionEntry(ConditionEntryField.PATH, '/bin/malware')], + }, + createExceptionListItemOptions({ + name: 'linux trusted app', + description: 'Linux Trusted App', + osTypes: ['linux'], + entries: [createEntryMatch('process.executable.caseless', '/bin/malware')], + }) + ); + }); + + it('should map macos trusted app condition properly', function () { + testMapping( + { + name: 'macos trusted app', + description: 'MacOS Trusted App', + os: OperatingSystem.MAC, + entries: [createConditionEntry(ConditionEntryField.PATH, '/bin/malware')], + }, + createExceptionListItemOptions({ + name: 'macos trusted app', + description: 'MacOS Trusted App', + osTypes: ['macos'], + entries: [createEntryMatch('process.executable.caseless', '/bin/malware')], + }) + ); + }); + + it('should map windows trusted app condition properly', function () { + testMapping( + { + name: 'windows trusted app', + description: 'Windows Trusted App', + os: OperatingSystem.WINDOWS, + entries: [createConditionEntry(ConditionEntryField.PATH, 'C:\\Program Files\\Malware')], + }, + createExceptionListItemOptions({ + name: 'windows trusted app', + description: 'Windows Trusted App', + osTypes: ['windows'], + entries: [createEntryMatch('process.executable.caseless', 'C:\\Program Files\\Malware')], + }) + ); + }); + + it('should map signer condition properly', function () { + testMapping( + { + name: 'Signed trusted app', + description: 'Signed Trusted App', + os: OperatingSystem.WINDOWS, + entries: [createConditionEntry(ConditionEntryField.SIGNER, 'Microsoft Windows')], + }, + createExceptionListItemOptions({ + name: 'Signed trusted app', + description: 'Signed Trusted App', + osTypes: ['windows'], + entries: [ + createEntryNested('process.Ext.code_signature', [ + createEntryMatch('trusted', 'true'), + createEntryMatch('subject_name', 'Microsoft Windows'), + ]), + ], + }) + ); + }); + + it('should map MD5 hash condition properly', function () { + testMapping( + { + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + ], + }, + createExceptionListItemOptions({ + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + osTypes: ['linux'], + entries: [createEntryMatch('process.hash.md5', '1234234659af249ddf3e40864e9fb241')], + }) + ); + }); + + it('should map SHA1 hash condition properly', function () { + testMapping( + { + name: 'SHA1 trusted app', + description: 'SHA1 Trusted App', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry( + ConditionEntryField.HASH, + 'f635da961234234659af249ddf3e40864e9fb241' + ), + ], + }, + createExceptionListItemOptions({ + name: 'SHA1 trusted app', + description: 'SHA1 Trusted App', + osTypes: ['linux'], + entries: [ + createEntryMatch('process.hash.sha1', 'f635da961234234659af249ddf3e40864e9fb241'), + ], + }) + ); + }); + + it('should map SHA256 hash condition properly', function () { + testMapping( + { + name: 'SHA256 trusted app', + description: 'SHA256 Trusted App', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry( + ConditionEntryField.HASH, + 'f635da96124659af249ddf3e40864e9fb234234659af249ddf3e40864e9fb241' + ), + ], + }, + createExceptionListItemOptions({ + name: 'SHA256 trusted app', + description: 'SHA256 Trusted App', + osTypes: ['linux'], + entries: [ + createEntryMatch( + 'process.hash.sha256', + 'f635da96124659af249ddf3e40864e9fb234234659af249ddf3e40864e9fb241' + ), + ], + }) + ); + }); + + it('should lowercase hash condition value', function () { + testMapping( + { + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.HASH, '1234234659Af249ddf3e40864E9FB241'), + ], + }, + createExceptionListItemOptions({ + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + osTypes: ['linux'], + entries: [createEntryMatch('process.hash.md5', '1234234659af249ddf3e40864e9fb241')], + }) + ); + }); + }); + + describe('exceptionListItemToTrustedApp', () => { + const testMapping = (input: ExceptionListItemSchema, expectedResult: TrustedApp) => { + expect(exceptionListItemToTrustedApp(input)).toEqual(expectedResult); + }; + + it('should map linux exception list item properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'linux trusted app', + description: 'Linux Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['linux'], + entries: [createEntryMatch('process.executable.caseless', '/bin/malware')], + }), + { + id: '123', + name: 'linux trusted app', + description: 'Linux Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.LINUX, + entries: [createConditionEntry(ConditionEntryField.PATH, '/bin/malware')], + } + ); + }); + + it('should map macos exception list item properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'macos trusted app', + description: 'MacOS Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['macos'], + entries: [createEntryMatch('process.executable.caseless', '/bin/malware')], + }), + { + id: '123', + name: 'macos trusted app', + description: 'MacOS Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.MAC, + entries: [createConditionEntry(ConditionEntryField.PATH, '/bin/malware')], + } + ); + }); + + it('should map windows exception list item properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'windows trusted app', + description: 'Windows Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['windows'], + entries: [createEntryMatch('process.executable.caseless', 'C:\\Program Files\\Malware')], + }), + { + id: '123', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + name: 'windows trusted app', + description: 'Windows Trusted App', + os: OperatingSystem.WINDOWS, + entries: [createConditionEntry(ConditionEntryField.PATH, 'C:\\Program Files\\Malware')], + } + ); + }); + + it('should map exception list item containing signer entry match properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'signed trusted app', + description: 'Signed trusted app', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['windows'], + entries: [ + createEntryNested('process.Ext.code_signature', [ + createEntryMatch('trusted', 'true'), + createEntryMatch('subject_name', 'Microsoft Windows'), + ]), + ], + }), + { + id: '123', + name: 'signed trusted app', + description: 'Signed trusted app', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.WINDOWS, + entries: [createConditionEntry(ConditionEntryField.SIGNER, 'Microsoft Windows')], + } + ); + }); + + it('should map exception list item containing MD5 hash entry match properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['linux'], + entries: [createEntryMatch('process.hash.md5', '1234234659af249ddf3e40864e9fb241')], + }), + { + id: '123', + name: 'MD5 trusted app', + description: 'MD5 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + ], + } + ); + }); + + it('should map exception list item containing SHA1 hash entry match properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'SHA1 trusted app', + description: 'SHA1 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['linux'], + entries: [ + createEntryMatch('process.hash.sha1', 'f635da961234234659af249ddf3e40864e9fb241'), + ], + }), + { + id: '123', + name: 'SHA1 trusted app', + description: 'SHA1 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry( + ConditionEntryField.HASH, + 'f635da961234234659af249ddf3e40864e9fb241' + ), + ], + } + ); + }); + + it('should map exception list item containing SHA256 hash entry match properly', function () { + testMapping( + exceptionListItemSchema({ + id: '123', + name: 'SHA256 trusted app', + description: 'SHA256 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os_types: ['linux'], + entries: [ + createEntryMatch( + 'process.hash.sha256', + 'f635da96124659af249ddf3e40864e9fb234234659af249ddf3e40864e9fb241' + ), + ], + }), + { + id: '123', + name: 'SHA256 trusted app', + description: 'SHA256 Trusted App', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry( + ConditionEntryField.HASH, + 'f635da96124659af249ddf3e40864e9fb234234659af249ddf3e40864e9fb241' + ), + ], + } + ); + }); + }); +}); diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.ts new file mode 100644 index 0000000000000..1121e27e6e7bc --- /dev/null +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/mapping.ts @@ -0,0 +1,185 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import uuid from 'uuid'; + +import { OsType } from '../../../../../lists/common/schemas/common'; +import { + EntriesArray, + EntryMatch, + EntryNested, + ExceptionListItemSchema, + NestedEntriesArray, +} from '../../../../../lists/common/shared_exports'; +import { ENDPOINT_TRUSTED_APPS_LIST_ID } from '../../../../../lists/common/constants'; +import { CreateExceptionListItemOptions } from '../../../../../lists/server'; +import { + ConditionEntry, + ConditionEntryField, + NewTrustedApp, + OperatingSystem, + TrustedApp, +} from '../../../../common/endpoint/types'; + +type ConditionEntriesMap = { [K in ConditionEntryField]?: ConditionEntry }; +type Mapping = { [K in T]: U }; + +const OS_TYPE_TO_OPERATING_SYSTEM: Mapping = { + linux: OperatingSystem.LINUX, + macos: OperatingSystem.MAC, + windows: OperatingSystem.WINDOWS, +}; + +const OPERATING_SYSTEM_TO_OS_TYPE: Mapping = { + [OperatingSystem.LINUX]: 'linux', + [OperatingSystem.MAC]: 'macos', + [OperatingSystem.WINDOWS]: 'windows', +}; + +const filterUndefined = (list: Array): T[] => { + return list.filter((item: T | undefined): item is T => item !== undefined); +}; + +export const createConditionEntry = ( + field: T, + value: string +): ConditionEntry => { + return { field, value, type: 'match', operator: 'included' }; +}; + +export const entriesToConditionEntriesMap = (entries: EntriesArray): ConditionEntriesMap => { + return entries.reduce((result, entry) => { + if (entry.field.startsWith('process.hash') && entry.type === 'match') { + return { + ...result, + [ConditionEntryField.HASH]: createConditionEntry(ConditionEntryField.HASH, entry.value), + }; + } else if (entry.field === 'process.executable.caseless' && entry.type === 'match') { + return { + ...result, + [ConditionEntryField.PATH]: createConditionEntry(ConditionEntryField.PATH, entry.value), + }; + } else if (entry.field === 'process.Ext.code_signature' && entry.type === 'nested') { + const subjectNameCondition = entry.entries.find((subEntry): subEntry is EntryMatch => { + return subEntry.field === 'subject_name' && subEntry.type === 'match'; + }); + + if (subjectNameCondition) { + return { + ...result, + [ConditionEntryField.SIGNER]: createConditionEntry( + ConditionEntryField.SIGNER, + subjectNameCondition.value + ), + }; + } + } + + return result; + }, {} as ConditionEntriesMap); +}; + +/** + * Map an ExceptionListItem to a TrustedApp item + * @param exceptionListItem + */ +export const exceptionListItemToTrustedApp = ( + exceptionListItem: ExceptionListItemSchema +): TrustedApp => { + if (exceptionListItem.os_types[0]) { + const os = OS_TYPE_TO_OPERATING_SYSTEM[exceptionListItem.os_types[0]]; + const grouped = entriesToConditionEntriesMap(exceptionListItem.entries); + + return { + id: exceptionListItem.id, + name: exceptionListItem.name, + description: exceptionListItem.description, + created_at: exceptionListItem.created_at, + created_by: exceptionListItem.created_by, + ...(os === OperatingSystem.LINUX || os === OperatingSystem.MAC + ? { + os, + entries: filterUndefined([ + grouped[ConditionEntryField.HASH], + grouped[ConditionEntryField.PATH], + ]), + } + : { + os, + entries: filterUndefined([ + grouped[ConditionEntryField.HASH], + grouped[ConditionEntryField.PATH], + grouped[ConditionEntryField.SIGNER], + ]), + }), + }; + } else { + throw new Error('Unknown Operating System assigned to trusted application.'); + } +}; + +const hashType = (hash: string): 'md5' | 'sha256' | 'sha1' | undefined => { + switch (hash.length) { + case 32: + return 'md5'; + case 40: + return 'sha1'; + case 64: + return 'sha256'; + } +}; + +export const createEntryMatch = (field: string, value: string): EntryMatch => { + return { field, value, type: 'match', operator: 'included' }; +}; + +export const createEntryNested = (field: string, entries: NestedEntriesArray): EntryNested => { + return { field, entries, type: 'nested' }; +}; + +export const conditionEntriesToEntries = ( + conditionEntries: Array> +): EntriesArray => { + return conditionEntries.map((conditionEntry) => { + if (conditionEntry.field === ConditionEntryField.HASH) { + return createEntryMatch( + `process.hash.${hashType(conditionEntry.value)}`, + conditionEntry.value.toLowerCase() + ); + } else if (conditionEntry.field === ConditionEntryField.SIGNER) { + return createEntryNested(`process.Ext.code_signature`, [ + createEntryMatch('trusted', 'true'), + createEntryMatch('subject_name', conditionEntry.value), + ]); + } else { + return createEntryMatch(`process.executable.caseless`, conditionEntry.value); + } + }); +}; + +/** + * Map NewTrustedApp to CreateExceptionListItemOptions. + */ +export const newTrustedAppToCreateExceptionListItemOptions = ({ + os, + entries, + name, + description = '', +}: NewTrustedApp): CreateExceptionListItemOptions => { + return { + comments: [], + description, + entries: conditionEntriesToEntries(entries), + itemId: uuid.v4(), + listId: ENDPOINT_TRUSTED_APPS_LIST_ID, + meta: undefined, + name, + namespaceType: 'agnostic', + osTypes: [OPERATING_SYSTEM_TO_OS_TYPE[os]], + tags: [], + type: 'simple', + }; +}; diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.test.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.test.ts new file mode 100644 index 0000000000000..04dec07f478e3 --- /dev/null +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.test.ts @@ -0,0 +1,123 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { ExceptionListItemSchema } from '../../../../../lists/common/schemas/response'; +import { listMock } from '../../../../../lists/server/mocks'; +import { ExceptionListClient } from '../../../../../lists/server'; +import { ConditionEntryField, OperatingSystem } from '../../../../common/endpoint/types'; +import { createConditionEntry, createEntryMatch } from './mapping'; +import { + createTrustedApp, + deleteTrustedApp, + getTrustedAppsList, + MissingTrustedAppException, +} from './service'; + +const exceptionsListClient = listMock.getExceptionListClient() as jest.Mocked; + +const EXCEPTION_LIST_ITEM: ExceptionListItemSchema = { + _version: '123', + id: '123', + comments: [], + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + description: 'Linux trusted app 1', + entries: [ + createEntryMatch('process.executable.caseless', '/bin/malware'), + createEntryMatch('process.hash.md5', '1234234659af249ddf3e40864e9fb241'), + ], + item_id: '123', + list_id: 'endpoint_trusted_apps', + meta: undefined, + name: 'linux trusted app 1', + namespace_type: 'agnostic', + os_types: ['linux'], + tags: [], + type: 'simple', + tie_breaker_id: '123', + updated_at: '11/11/2011T11:11:11.111', + updated_by: 'admin', +}; + +const TRUSTED_APP = { + id: '123', + created_at: '11/11/2011T11:11:11.111', + created_by: 'admin', + name: 'linux trusted app 1', + description: 'Linux trusted app 1', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + createConditionEntry(ConditionEntryField.PATH, '/bin/malware'), + ], +}; + +describe('service', () => { + beforeEach(() => { + exceptionsListClient.deleteExceptionListItem.mockReset(); + exceptionsListClient.createExceptionListItem.mockReset(); + exceptionsListClient.findExceptionListItem.mockReset(); + exceptionsListClient.createTrustedAppsList.mockReset(); + }); + + describe('deleteTrustedApp', () => { + it('should delete existing trusted app', async () => { + exceptionsListClient.deleteExceptionListItem.mockResolvedValue(EXCEPTION_LIST_ITEM); + + expect(await deleteTrustedApp(exceptionsListClient, { id: '123' })).toBeUndefined(); + + expect(exceptionsListClient.deleteExceptionListItem).toHaveBeenCalledWith({ + id: '123', + namespaceType: 'agnostic', + }); + }); + + it('should throw for non existing trusted app', async () => { + exceptionsListClient.deleteExceptionListItem.mockResolvedValue(null); + + await expect(deleteTrustedApp(exceptionsListClient, { id: '123' })).rejects.toBeInstanceOf( + MissingTrustedAppException + ); + }); + }); + + describe('createTrustedApp', () => { + it('should create trusted app', async () => { + exceptionsListClient.createExceptionListItem.mockResolvedValue(EXCEPTION_LIST_ITEM); + + const result = await createTrustedApp(exceptionsListClient, { + name: 'linux trusted app 1', + description: 'Linux trusted app 1', + os: OperatingSystem.LINUX, + entries: [ + createConditionEntry(ConditionEntryField.PATH, '/bin/malware'), + createConditionEntry(ConditionEntryField.HASH, '1234234659af249ddf3e40864e9fb241'), + ], + }); + + expect(result).toEqual({ data: TRUSTED_APP }); + + expect(exceptionsListClient.createTrustedAppsList).toHaveBeenCalled(); + }); + }); + + describe('getTrustedAppsList', () => { + it('should get trusted apps', async () => { + exceptionsListClient.findExceptionListItem.mockResolvedValue({ + data: [EXCEPTION_LIST_ITEM], + page: 1, + per_page: 20, + total: 100, + }); + + const result = await getTrustedAppsList(exceptionsListClient, { page: 1, per_page: 20 }); + + expect(result).toEqual({ data: [TRUSTED_APP], page: 1, per_page: 20, total: 100 }); + + expect(exceptionsListClient.createTrustedAppsList).toHaveBeenCalled(); + }); + }); +}); diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.ts new file mode 100644 index 0000000000000..f86c73f18a315 --- /dev/null +++ b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/service.ts @@ -0,0 +1,79 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import { ExceptionListClient } from '../../../../../lists/server'; +import { ENDPOINT_TRUSTED_APPS_LIST_ID } from '../../../../../lists/common/constants'; + +import { + DeleteTrustedAppsRequestParams, + GetTrustedAppsListRequest, + GetTrustedListAppsResponse, + PostTrustedAppCreateRequest, + PostTrustedAppCreateResponse, +} from '../../../../common/endpoint/types'; + +import { + exceptionListItemToTrustedApp, + newTrustedAppToCreateExceptionListItemOptions, +} from './mapping'; + +export class MissingTrustedAppException { + constructor(public id: string) {} +} + +export const deleteTrustedApp = async ( + exceptionsListClient: ExceptionListClient, + { id }: DeleteTrustedAppsRequestParams +) => { + const exceptionListItem = await exceptionsListClient.deleteExceptionListItem({ + id, + itemId: undefined, + namespaceType: 'agnostic', + }); + + if (!exceptionListItem) { + throw new MissingTrustedAppException(id); + } +}; + +export const getTrustedAppsList = async ( + exceptionsListClient: ExceptionListClient, + { page, per_page: perPage }: GetTrustedAppsListRequest +): Promise => { + // Ensure list is created if it does not exist + await exceptionsListClient.createTrustedAppsList(); + + const results = await exceptionsListClient.findExceptionListItem({ + listId: ENDPOINT_TRUSTED_APPS_LIST_ID, + page, + perPage, + filter: undefined, + namespaceType: 'agnostic', + sortField: 'name', + sortOrder: 'asc', + }); + + return { + data: results?.data.map(exceptionListItemToTrustedApp) ?? [], + total: results?.total ?? 0, + page: results?.page ?? 1, + per_page: results?.per_page ?? perPage!, + }; +}; + +export const createTrustedApp = async ( + exceptionsListClient: ExceptionListClient, + newTrustedApp: PostTrustedAppCreateRequest +): Promise => { + // Ensure list is created if it does not exist + await exceptionsListClient.createTrustedAppsList(); + + const createdTrustedAppExceptionItem = await exceptionsListClient.createExceptionListItem( + newTrustedAppToCreateExceptionListItemOptions(newTrustedApp) + ); + + return { data: exceptionListItemToTrustedApp(createdTrustedAppExceptionItem) }; +}; diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/trusted_apps.test.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/trusted_apps.test.ts deleted file mode 100644 index 0fc469fa62a80..0000000000000 --- a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/trusted_apps.test.ts +++ /dev/null @@ -1,522 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ - -import { EndpointAppContextService } from '../../endpoint_app_context_services'; -import { - createMockEndpointAppContext, - createMockEndpointAppContextServiceStartContract, -} from '../../mocks'; -import { IRouter, KibanaRequest, RequestHandler } from 'kibana/server'; -import { httpServerMock, httpServiceMock } from '../../../../../../../src/core/server/mocks'; -import { registerTrustedAppsRoutes } from './index'; -import { - TRUSTED_APPS_CREATE_API, - TRUSTED_APPS_DELETE_API, - TRUSTED_APPS_LIST_API, -} from '../../../../common/endpoint/constants'; -import { - DeleteTrustedAppsRequestParams, - GetTrustedAppsListRequest, - PostTrustedAppCreateRequest, -} from '../../../../common/endpoint/types'; -import { xpackMocks } from '../../../../../../mocks'; -import { ENDPOINT_TRUSTED_APPS_LIST_ID } from '../../../../../lists/common/constants'; -import { EndpointAppContext } from '../../types'; -import { ExceptionListClient, ListClient } from '../../../../../lists/server'; -import { listMock } from '../../../../../lists/server/mocks'; -import { - ExceptionListItemSchema, - FoundExceptionListItemSchema, -} from '../../../../../lists/common/schemas/response'; -import { getExceptionListItemSchemaMock } from '../../../../../lists/common/schemas/response/exception_list_item_schema.mock'; - -type RequestHandlerContextWithLists = ReturnType & { - lists?: { - getListClient: () => jest.Mocked; - getExceptionListClient: () => jest.Mocked; - }; -}; - -describe('when invoking endpoint trusted apps route handlers', () => { - let routerMock: jest.Mocked; - let endpointAppContextService: EndpointAppContextService; - let context: RequestHandlerContextWithLists; - let response: ReturnType; - let exceptionsListClient: jest.Mocked; - let endpointAppContext: EndpointAppContext; - - beforeEach(() => { - routerMock = httpServiceMock.createRouter(); - endpointAppContextService = new EndpointAppContextService(); - const startContract = createMockEndpointAppContextServiceStartContract(); - exceptionsListClient = listMock.getExceptionListClient() as jest.Mocked; - endpointAppContextService.start(startContract); - endpointAppContext = { - ...createMockEndpointAppContext(), - service: endpointAppContextService, - }; - registerTrustedAppsRoutes(routerMock, endpointAppContext); - - // For use in individual API calls - context = { - ...xpackMocks.createRequestHandlerContext(), - lists: { - getListClient: jest.fn(), - getExceptionListClient: jest.fn().mockReturnValue(exceptionsListClient), - }, - }; - response = httpServerMock.createResponseFactory(); - }); - - describe('when fetching list of trusted apps', () => { - let routeHandler: RequestHandler; - const createListRequest = (page: number = 1, perPage: number = 20) => { - return httpServerMock.createKibanaRequest({ - path: TRUSTED_APPS_LIST_API, - method: 'get', - query: { - page, - per_page: perPage, - }, - }); - }; - - beforeEach(() => { - // Get the registered List handler from the IRouter instance - [, routeHandler] = routerMock.get.mock.calls.find(([{ path }]) => - path.startsWith(TRUSTED_APPS_LIST_API) - )!; - }); - - it('should use ExceptionListClient from route handler context', async () => { - const request = createListRequest(); - await routeHandler(context, request, response); - expect(context.lists?.getExceptionListClient).toHaveBeenCalled(); - }); - - it('should create the Trusted Apps List first', async () => { - const request = createListRequest(); - await routeHandler(context, request, response); - expect(exceptionsListClient.createTrustedAppsList).toHaveBeenCalled(); - expect(response.ok).toHaveBeenCalled(); - }); - - it('should pass pagination query params to exception list service', async () => { - const request = createListRequest(10, 100); - const emptyResponse = { - data: [], - page: 10, - per_page: 100, - total: 0, - }; - - exceptionsListClient.findExceptionListItem.mockResolvedValue(emptyResponse); - await routeHandler(context, request, response); - - expect(response.ok).toHaveBeenCalledWith({ body: emptyResponse }); - expect(exceptionsListClient.findExceptionListItem).toHaveBeenCalledWith({ - listId: ENDPOINT_TRUSTED_APPS_LIST_ID, - page: 10, - perPage: 100, - filter: undefined, - namespaceType: 'agnostic', - sortField: 'name', - sortOrder: 'asc', - }); - }); - - it('should map Exception List Item to Trusted App item', async () => { - const request = createListRequest(10, 100); - const emptyResponse: FoundExceptionListItemSchema = { - data: [ - { - _version: undefined, - comments: [], - created_at: '2020-09-21T19:43:48.240Z', - created_by: 'test', - description: '', - entries: [ - { - field: 'process.hash.sha256', - operator: 'included', - type: 'match', - value: 'a4370c0cf81686c0b696fa6261c9d3e0d810ae704ab8301839dffd5d5112f476', - }, - { - field: 'process.hash.sha1', - operator: 'included', - type: 'match', - value: 'aedb279e378bed6c2db3c9dc9e12ba635e0b391c', - }, - { - field: 'process.hash.md5', - operator: 'included', - type: 'match', - value: '741462ab431a22233c787baab9b653c7', - }, - ], - id: '1', - item_id: '11', - list_id: 'trusted apps test', - meta: undefined, - name: 'test', - namespace_type: 'agnostic', - os_types: ['windows'], - tags: [], - tie_breaker_id: '1', - type: 'simple', - updated_at: '2020-09-21T19:43:48.240Z', - updated_by: 'test', - }, - ], - page: 10, - per_page: 100, - total: 0, - }; - - exceptionsListClient.findExceptionListItem.mockResolvedValue(emptyResponse); - await routeHandler(context, request, response); - - expect(response.ok).toHaveBeenCalledWith({ - body: { - data: [ - { - created_at: '2020-09-21T19:43:48.240Z', - created_by: 'test', - description: '', - entries: [ - { - field: 'process.hash.*', - operator: 'included', - type: 'match', - value: 'a4370c0cf81686c0b696fa6261c9d3e0d810ae704ab8301839dffd5d5112f476', - }, - { - field: 'process.hash.*', - operator: 'included', - type: 'match', - value: 'aedb279e378bed6c2db3c9dc9e12ba635e0b391c', - }, - { - field: 'process.hash.*', - operator: 'included', - type: 'match', - value: '741462ab431a22233c787baab9b653c7', - }, - ], - id: '1', - name: 'test', - os: 'windows', - }, - ], - page: 10, - per_page: 100, - total: 0, - }, - }); - }); - - it('should log unexpected error if one occurs', async () => { - exceptionsListClient.findExceptionListItem.mockImplementation(() => { - throw new Error('expected error'); - }); - const request = createListRequest(10, 100); - await routeHandler(context, request, response); - expect(response.internalError).toHaveBeenCalled(); - expect(endpointAppContext.logFactory.get('trusted_apps').error).toHaveBeenCalled(); - }); - }); - - describe('when creating a trusted app', () => { - let routeHandler: RequestHandler; - const createNewTrustedAppBody = (): { - -readonly [k in keyof PostTrustedAppCreateRequest]: PostTrustedAppCreateRequest[k]; - } => ({ - name: 'Some Anti-Virus App', - description: 'this one is ok', - os: 'windows', - entries: [ - { - field: 'process.executable.caseless', - type: 'match', - operator: 'included', - value: 'c:/programs files/Anti-Virus', - }, - ], - }); - const createPostRequest = (body?: PostTrustedAppCreateRequest) => { - return httpServerMock.createKibanaRequest({ - path: TRUSTED_APPS_LIST_API, - method: 'post', - body: body ?? createNewTrustedAppBody(), - }); - }; - - beforeEach(() => { - // Get the registered POST handler from the IRouter instance - [, routeHandler] = routerMock.post.mock.calls.find(([{ path }]) => - path.startsWith(TRUSTED_APPS_CREATE_API) - )!; - - // Mock the impelementation of `createExceptionListItem()` so that the return value - // merges in the provided input - exceptionsListClient.createExceptionListItem.mockImplementation(async (newExceptionItem) => { - return ({ - ...getExceptionListItemSchemaMock(), - ...newExceptionItem, - os_types: newExceptionItem.osTypes, - } as unknown) as ExceptionListItemSchema; - }); - }); - - it('should use ExceptionListClient from route handler context', async () => { - const request = createPostRequest(); - await routeHandler(context, request, response); - expect(context.lists?.getExceptionListClient).toHaveBeenCalled(); - }); - - it('should create trusted app list first', async () => { - const request = createPostRequest(); - await routeHandler(context, request, response); - expect(exceptionsListClient.createTrustedAppsList).toHaveBeenCalled(); - expect(response.ok).toHaveBeenCalled(); - }); - - it('should map new trusted app item to an exception list item', async () => { - const request = createPostRequest(); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0]).toEqual({ - comments: [], - description: 'this one is ok', - entries: [ - { - field: 'process.executable.caseless', - operator: 'included', - type: 'match', - value: 'c:/programs files/Anti-Virus', - }, - ], - itemId: expect.stringMatching(/.*/), - listId: 'endpoint_trusted_apps', - meta: undefined, - name: 'Some Anti-Virus App', - namespaceType: 'agnostic', - osTypes: ['windows'], - tags: [], - type: 'simple', - }); - }); - - it('should return new trusted app item', async () => { - const request = createPostRequest(); - await routeHandler(context, request, response); - expect(response.ok.mock.calls[0][0]).toEqual({ - body: { - data: { - created_at: '2020-04-20T15:25:31.830Z', - created_by: 'some user', - description: 'this one is ok', - entries: [ - { - field: 'process.executable.caseless', - operator: 'included', - type: 'match', - value: 'c:/programs files/Anti-Virus', - }, - ], - id: '1', - name: 'Some Anti-Virus App', - os: 'windows', - }, - }, - }); - }); - - it('should log unexpected error if one occurs', async () => { - exceptionsListClient.createExceptionListItem.mockImplementation(() => { - throw new Error('expected error for create'); - }); - const request = createPostRequest(); - await routeHandler(context, request, response); - expect(response.internalError).toHaveBeenCalled(); - expect(endpointAppContext.logFactory.get('trusted_apps').error).toHaveBeenCalled(); - }); - - it('should trim trusted app entry name', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.name = `\n ${newTrustedApp.name} \r\n`; - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].name).toEqual( - 'Some Anti-Virus App' - ); - }); - - it('should trim condition entry values', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.entries.push({ - field: 'process.executable.caseless', - value: '\n some value \r\n ', - operator: 'included', - type: 'match', - }); - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].entries).toEqual([ - { - field: 'process.executable.caseless', - operator: 'included', - type: 'match', - value: 'c:/programs files/Anti-Virus', - }, - { - field: 'process.executable.caseless', - value: 'some value', - operator: 'included', - type: 'match', - }, - ]); - }); - - it('should convert hash values to lowercase', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.entries.push({ - field: 'process.hash.*', - value: '741462AB431A22233C787BAAB9B653C7', - operator: 'included', - type: 'match', - }); - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].entries).toEqual([ - { - field: 'process.executable.caseless', - operator: 'included', - type: 'match', - value: 'c:/programs files/Anti-Virus', - }, - { - field: 'process.hash.md5', - value: '741462ab431a22233c787baab9b653c7', - operator: 'included', - type: 'match', - }, - ]); - }); - - it('should detect md5 hash', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.entries = [ - { - field: 'process.hash.*', - value: '741462ab431a22233c787baab9b653c7', - operator: 'included', - type: 'match', - }, - ]; - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].entries).toEqual([ - { - field: 'process.hash.md5', - value: '741462ab431a22233c787baab9b653c7', - operator: 'included', - type: 'match', - }, - ]); - }); - - it('should detect sha1 hash', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.entries = [ - { - field: 'process.hash.*', - value: 'aedb279e378bed6c2db3c9dc9e12ba635e0b391c', - operator: 'included', - type: 'match', - }, - ]; - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].entries).toEqual([ - { - field: 'process.hash.sha1', - value: 'aedb279e378bed6c2db3c9dc9e12ba635e0b391c', - operator: 'included', - type: 'match', - }, - ]); - }); - - it('should detect sha256 hash', async () => { - const newTrustedApp = createNewTrustedAppBody(); - newTrustedApp.entries = [ - { - field: 'process.hash.*', - value: 'a4370c0cf81686c0b696fa6261c9d3e0d810ae704ab8301839dffd5d5112f476', - operator: 'included', - type: 'match', - }, - ]; - const request = createPostRequest(newTrustedApp); - await routeHandler(context, request, response); - expect(exceptionsListClient.createExceptionListItem.mock.calls[0][0].entries).toEqual([ - { - field: 'process.hash.sha256', - value: 'a4370c0cf81686c0b696fa6261c9d3e0d810ae704ab8301839dffd5d5112f476', - operator: 'included', - type: 'match', - }, - ]); - }); - }); - - describe('when deleting a trusted app', () => { - let routeHandler: RequestHandler; - let request: KibanaRequest; - - beforeEach(() => { - [, routeHandler] = routerMock.delete.mock.calls.find(([{ path }]) => - path.startsWith(TRUSTED_APPS_DELETE_API) - )!; - - request = httpServerMock.createKibanaRequest({ - path: TRUSTED_APPS_DELETE_API.replace('{id}', '123'), - method: 'delete', - }); - }); - - it('should use ExceptionListClient from route handler context', async () => { - await routeHandler(context, request, response); - expect(context.lists?.getExceptionListClient).toHaveBeenCalled(); - }); - - it('should return 200 on successful delete', async () => { - await routeHandler(context, request, response); - expect(exceptionsListClient.deleteExceptionListItem).toHaveBeenCalledWith({ - id: request.params.id, - itemId: undefined, - namespaceType: 'agnostic', - }); - expect(response.ok).toHaveBeenCalled(); - }); - - it('should return 404 if item does not exist', async () => { - exceptionsListClient.deleteExceptionListItem.mockResolvedValueOnce(null); - await routeHandler(context, request, response); - expect(response.notFound).toHaveBeenCalled(); - }); - - it('should log unexpected error if one occurs', async () => { - exceptionsListClient.deleteExceptionListItem.mockImplementation(() => { - throw new Error('expected error for delete'); - }); - await routeHandler(context, request, response); - expect(response.internalError).toHaveBeenCalled(); - expect(endpointAppContext.logFactory.get('trusted_apps').error).toHaveBeenCalled(); - }); - }); -}); diff --git a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/utils.ts b/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/utils.ts deleted file mode 100644 index 322d9a65162c0..0000000000000 --- a/x-pack/plugins/security_solution/server/endpoint/routes/trusted_apps/utils.ts +++ /dev/null @@ -1,87 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ - -import uuid from 'uuid'; -import { ExceptionListItemSchema } from '../../../../../lists/common/shared_exports'; -import { NewTrustedApp, TrustedApp } from '../../../../common/endpoint/types'; -import { ExceptionListClient } from '../../../../../lists/server'; -import { ENDPOINT_TRUSTED_APPS_LIST_ID } from '../../../../../lists/common/constants'; - -type NewExceptionItem = Parameters[0]; - -/** - * Map an ExcptionListItem to a TrustedApp item - * @param exceptionListItem - */ -export const exceptionItemToTrustedAppItem = ( - exceptionListItem: ExceptionListItemSchema -): TrustedApp => { - // eslint-disable-next-line @typescript-eslint/naming-convention - const { entries, description, created_by, created_at, name, os_types, id } = exceptionListItem; - const os = os_types.length ? os_types[0] : 'unknown'; - return { - entries: entries.map((entry) => { - if (entry.field.startsWith('process.hash')) { - return { - ...entry, - field: 'process.hash.*', - }; - } - return entry; - }), - description, - created_at, - created_by, - name, - os, - id, - } as TrustedApp; -}; - -export const newTrustedAppItemToExceptionItem = ({ - os, - entries, - name, - description = '', -}: NewTrustedApp): NewExceptionItem => { - return { - comments: [], - description, - // @ts-ignore - entries: entries.map(({ value, ...newEntry }) => { - let newValue = value.trim(); - - if (newEntry.field === 'process.hash.*') { - newValue = newValue.toLowerCase(); - newEntry.field = `process.hash.${hashType(newValue)}`; - } - - return { - ...newEntry, - value: newValue, - }; - }), - itemId: uuid.v4(), - listId: ENDPOINT_TRUSTED_APPS_LIST_ID, - meta: undefined, - name: name.trim(), - namespaceType: 'agnostic', - osTypes: [os], - tags: [], - type: 'simple', - }; -}; - -const hashType = (hash: string): 'md5' | 'sha256' | 'sha1' | undefined => { - switch (hash.length) { - case 32: - return 'md5'; - case 40: - return 'sha1'; - case 64: - return 'sha256'; - } -}; diff --git a/x-pack/plugins/spaces/server/usage_collection/spaces_usage_collector.ts b/x-pack/plugins/spaces/server/usage_collection/spaces_usage_collector.ts index 0e31c930a926b..d563a4a9b100d 100644 --- a/x-pack/plugins/spaces/server/usage_collection/spaces_usage_collector.ts +++ b/x-pack/plugins/spaces/server/usage_collection/spaces_usage_collector.ts @@ -8,7 +8,6 @@ import { LegacyCallAPIOptions } from 'src/core/server'; import { take } from 'rxjs/operators'; import { CollectorFetchContext, UsageCollectionSetup } from 'src/plugins/usage_collection/server'; import { Observable } from 'rxjs'; -import { KIBANA_STATS_TYPE_MONITORING } from '../../../monitoring/common/constants'; import { PluginsSetup } from '../plugin'; type CallCluster = ( @@ -146,11 +145,6 @@ interface CollectorDeps { licensing: PluginsSetup['licensing']; } -interface BulkUpload { - usage: { - spaces: UsageStats; - }; -} /* * @param {Object} server * @return {Object} kibana usage stats type collection object @@ -159,7 +153,7 @@ export function getSpacesUsageCollector( usageCollection: UsageCollectionSetup, deps: CollectorDeps ) { - return usageCollection.makeUsageCollector({ + return usageCollection.makeUsageCollector({ type: 'spaces', isReady: () => true, schema: { @@ -202,22 +196,6 @@ export function getSpacesUsageCollector( ...usageStats, } as UsageStats; }, - - /* - * Format the response data into a model for internal upload - * 1. Make this data part of the "kibana_stats" type - * 2. Organize the payload in the usage.xpack.spaces namespace of the data payload - */ - formatForBulkUpload: (result: UsageStats) => { - return { - type: KIBANA_STATS_TYPE_MONITORING, - payload: { - usage: { - spaces: result, - }, - }, - }; - }, }); } diff --git a/x-pack/plugins/translations/translations/ja-JP.json b/x-pack/plugins/translations/translations/ja-JP.json index ed514eda000aa..261458a8e7793 100644 --- a/x-pack/plugins/translations/translations/ja-JP.json +++ b/x-pack/plugins/translations/translations/ja-JP.json @@ -20634,11 +20634,8 @@ "xpack.uptime.monitorList.defineConnector.description": "アラートを有効にするには、デフォルトのアラートアクションコネクターを定義してください。", "xpack.uptime.monitorList.disableDownAlert": "ステータスアラートを無効にする", "xpack.uptime.monitorList.downLineSeries.downLabel": "ダウン", - "xpack.uptime.monitorList.drawer.locations.statusDown": "{locations}でダウン", - "xpack.uptime.monitorList.drawer.locations.statusUp": "{locations}でアップ", "xpack.uptime.monitorList.drawer.missingLocation": "一部のHeartbeatインスタンスには位置情報が定義されていません。Heartbeat構成への{link}。", "xpack.uptime.monitorList.enabledAlerts.noAlert": "このモニターではアラートが有効ではありません。", - "xpack.uptime.monitorList.enabledAlerts.title": "有効なアラート：", "xpack.uptime.monitorList.enableDownAlert": "ステータスアラートを有効にする", "xpack.uptime.monitorList.expandDrawerButton.ariaLabel": "ID {id}のモニターの行を展開", "xpack.uptime.monitorList.geoName.helpLinkAnnotation": "場所を追加", diff --git a/x-pack/plugins/translations/translations/zh-CN.json b/x-pack/plugins/translations/translations/zh-CN.json index a500b63fbf863..f18c899f67652 100644 --- a/x-pack/plugins/translations/translations/zh-CN.json +++ b/x-pack/plugins/translations/translations/zh-CN.json @@ -20654,11 +20654,8 @@ "xpack.uptime.monitorList.defineConnector.description": "要开始启用告警，请在以下位置定义默认告警操作连接器", "xpack.uptime.monitorList.disableDownAlert": "禁用状态告警", "xpack.uptime.monitorList.downLineSeries.downLabel": "关闭", - "xpack.uptime.monitorList.drawer.locations.statusDown": "在 {locations} 已关闭", - "xpack.uptime.monitorList.drawer.locations.statusUp": "在 {locations} 正运行", "xpack.uptime.monitorList.drawer.missingLocation": "某些 Heartbeat 实例未定义位置。{link}到您的 Heartbeat 配置。", "xpack.uptime.monitorList.enabledAlerts.noAlert": "没有为此监测启用告警。", - "xpack.uptime.monitorList.enabledAlerts.title": "已启用的告警：", "xpack.uptime.monitorList.enableDownAlert": "启用状态告警", "xpack.uptime.monitorList.expandDrawerButton.ariaLabel": "展开 ID {id} 的监测行", "xpack.uptime.monitorList.geoName.helpLinkAnnotation": "添加位置", diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.test.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.test.tsx index 3cd54b58bf29a..6ead65d958bd5 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.test.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.test.tsx @@ -33,4 +33,97 @@ describe('EmailParamsFields renders', () => { expect(wrapper.find('[data-test-subj="subjectInput"]').length > 0).toBeTruthy(); expect(wrapper.find('[data-test-subj="messageTextArea"]').length > 0).toBeTruthy(); }); + + test('message param field is rendered with default value if not set', () => { + const actionParams = { + cc: [], + bcc: [], + to: ['test@test.com'], + subject: 'test', + }; + + const editAction = jest.fn(); + mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + }); + + test('when the default message changes, so is the underlying message if it was set by the previous default', () => { + const actionParams = { + cc: [], + bcc: [], + to: ['test@test.com'], + subject: 'test', + }; + + const editAction = jest.fn(); + const wrapper = mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + + wrapper.setProps({ + defaultMessage: 'Some different default message', + }); + + expect(editAction).toHaveBeenCalledWith('message', 'Some different default message', 0); + }); + + test('when the default message changes, it doesnt change the underlying message if it wasnt set by a previous default', () => { + const actionParams = { + cc: [], + bcc: [], + to: ['test@test.com'], + subject: 'test', + }; + + const editAction = jest.fn(); + const wrapper = mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + + // simulate value being updated + const valueToSimulate = 'some new value'; + wrapper + .find('[data-test-subj="messageTextArea"]') + .first() + .simulate('change', { target: { value: valueToSimulate } }); + expect(editAction).toHaveBeenCalledWith('message', valueToSimulate, 0); + wrapper.setProps({ + actionParams: { + ...actionParams, + message: valueToSimulate, + }, + }); + + // simulate default changing + wrapper.setProps({ + defaultMessage: 'Some different default message', + }); + + expect(editAction).not.toHaveBeenCalledWith('message', 'Some different default message', 0); + }); }); diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.tsx index 26ab5b21e167a..1030ce34d2569 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/email/email_params.tsx @@ -11,7 +11,6 @@ import { ActionParamsProps } from '../../../../types'; import { EmailActionParams } from '../types'; import { TextFieldWithMessageVariables } from '../../text_field_with_message_variables'; import { TextAreaWithMessageVariables } from '../../text_area_with_message_variables'; -import { recoveredActionGroupMessage } from '../../../constants'; export const EmailParamsFields = ({ actionParams, @@ -28,17 +27,19 @@ export const EmailParamsFields = ({ const [addCC, setAddCC] = useState(false); const [addBCC, setAddBCC] = useState(false); + const [[isUsingDefault, defaultMessageUsed], setDefaultMessageUsage] = useState< + [boolean, string | undefined] + >([false, defaultMessage]); useEffect(() => { - if (defaultMessage === recoveredActionGroupMessage) { - editAction('message', defaultMessage, index); - } else if ( - (!message || message === recoveredActionGroupMessage) && - defaultMessage && - defaultMessage.length > 0 + if ( + !actionParams?.message || + (isUsingDefault && + actionParams?.message === defaultMessageUsed && + defaultMessageUsed !== defaultMessage) ) { + setDefaultMessageUsage([true, defaultMessage]); editAction('message', defaultMessage, index); } - // eslint-disable-next-line react-hooks/exhaustive-deps }, [defaultMessage]); diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/search_issues.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/search_issues.tsx index fff606982677a..8a98a9eb7bb75 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/search_issues.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/search_issues.tsx @@ -14,7 +14,7 @@ import { useGetSingleIssue } from './use_get_single_issue'; import * as i18n from './translations'; interface Props { - selectedValue: string | null; + selectedValue?: string | null; http: HttpSetup; toastNotifications: Pick< ToastsApi, diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_fields_by_issue_type.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_fields_by_issue_type.tsx index 8685ee1e615b0..6129f42923e45 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_fields_by_issue_type.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_fields_by_issue_type.tsx @@ -23,7 +23,7 @@ interface Props { ToastsApi, 'get$' | 'add' | 'remove' | 'addSuccess' | 'addWarning' | 'addDanger' | 'addError' >; - issueType: string; + issueType: string | undefined; actionConnector?: ActionConnector; } diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_single_issue.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_single_issue.tsx index c0d2eae14bead..85fc94733e8a8 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_single_issue.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/jira/use_get_single_issue.tsx @@ -22,7 +22,7 @@ interface Props { ToastsApi, 'get$' | 'add' | 'remove' | 'addSuccess' | 'addWarning' | 'addDanger' | 'addError' >; - id: string | null; + id?: string | null; actionConnector?: ActionConnector; } diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.test.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.test.tsx index 0552a126ca66f..86dd304bf6b12 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.test.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.test.tsx @@ -9,8 +9,8 @@ import { ServerLogLevelOptions } from '.././types'; import ServerLogParamsFields from './server_log_params'; describe('ServerLogParamsFields renders', () => { - const editAction = jest.fn(); test('all params fields is rendered', () => { + const editAction = jest.fn(); const actionParams = { level: ServerLogLevelOptions.TRACE, message: 'test', @@ -35,20 +35,103 @@ describe('ServerLogParamsFields renders', () => { test('level param field is rendered with default value if not selected', () => { const actionParams = { message: 'test message', - level: ServerLogLevelOptions.INFO, }; + const editAction = jest.fn(); + + mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('level', 'info', 0); + }); + + test('message param field is rendered with default value if not set', () => { + const actionParams = { + level: ServerLogLevelOptions.TRACE, + }; + + const editAction = jest.fn(); + + mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + }); + + test('when the default message changes, so is the underlying message if it was set by the previous default', () => { + const actionParams = { + level: ServerLogLevelOptions.TRACE, + }; + + const editAction = jest.fn(); const wrapper = mountWithIntl( {}} + editAction={editAction} index={0} /> ); - expect(wrapper.find('[data-test-subj="loggingLevelSelect"]').length > 0).toBeTruthy(); - expect( - wrapper.find('[data-test-subj="loggingLevelSelect"]').first().prop('value') - ).toStrictEqual('info'); - expect(wrapper.find('[data-test-subj="messageTextArea"]').length > 0).toBeTruthy(); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + + wrapper.setProps({ + defaultMessage: 'Some different default message', + }); + + expect(editAction).toHaveBeenCalledWith('message', 'Some different default message', 0); + }); + + test('when the default message changes, it doesnt change the underlying message if it wasnt set by a previous default', () => { + const actionParams = { + level: ServerLogLevelOptions.TRACE, + }; + + const editAction = jest.fn(); + const wrapper = mountWithIntl( + + ); + + expect(editAction).toHaveBeenCalledWith('message', 'Some default message', 0); + + // simulate value being updated + const valueToSimulate = 'some new value'; + wrapper + .find('[data-test-subj="messageTextArea"]') + .first() + .simulate('change', { target: { value: valueToSimulate } }); + expect(editAction).toHaveBeenCalledWith('message', valueToSimulate, 0); + wrapper.setProps({ + actionParams: { + ...actionParams, + message: valueToSimulate, + }, + }); + + // simulate default changing + wrapper.setProps({ + defaultMessage: 'Some different default message', + }); + + expect(editAction).not.toHaveBeenCalledWith('message', 'Some different default message', 0); }); }); diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.tsx index 8d52efd1f328a..ce426c72b64b4 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/server_log/server_log_params.tsx @@ -3,13 +3,12 @@ * or more contributor license agreements. Licensed under the Elastic License; * you may not use this file except in compliance with the Elastic License. */ -import React, { Fragment, useEffect } from 'react'; +import React, { Fragment, useEffect, useState } from 'react'; import { i18n } from '@kbn/i18n'; import { EuiSelect, EuiFormRow } from '@elastic/eui'; import { ActionParamsProps } from '../../../../types'; import { ServerLogActionParams } from '.././types'; import { TextAreaWithMessageVariables } from '../../text_area_with_message_variables'; -import { recoveredActionGroupMessage } from '../../../constants'; export const ServerLogParamsFields: React.FunctionComponent< ActionParamsProps @@ -23,25 +22,26 @@ export const ServerLogParamsFields: React.FunctionComponent< { value: 'error', text: 'Error' }, { value: 'fatal', text: 'Fatal' }, ]; - useEffect(() => { - if (!actionParams?.level) { + if (!actionParams.level) { editAction('level', 'info', index); } // eslint-disable-next-line react-hooks/exhaustive-deps }, []); + const [[isUsingDefault, defaultMessageUsed], setDefaultMessageUsage] = useState< + [boolean, string | undefined] + >([false, defaultMessage]); useEffect(() => { - if (defaultMessage === recoveredActionGroupMessage) { - editAction('message', defaultMessage, index); - } else if ( - (!message || message === recoveredActionGroupMessage) && - defaultMessage && - defaultMessage.length > 0 + if ( + !actionParams?.message || + (isUsingDefault && + actionParams?.message === defaultMessageUsed && + defaultMessageUsed !== defaultMessage) ) { + setDefaultMessageUsage([true, defaultMessage]); editAction('message', defaultMessage, index); } - // eslint-disable-next-line react-hooks/exhaustive-deps }, [defaultMessage]); diff --git a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/slack/slack_params.tsx b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/slack/slack_params.tsx index cbc6da3607c19..40818c327af60 100644 --- a/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/slack/slack_params.tsx +++ b/x-pack/plugins/triggers_actions_ui/public/application/components/builtin_action_types/slack/slack_params.tsx @@ -3,12 +3,11 @@ * or more contributor license agreements. Licensed under the Elastic License; * you may not use this file except in compliance with the Elastic License. */ -import React, { useEffect } from 'react'; +import React, { useEffect, useState } from 'react'; import { i18n } from '@kbn/i18n'; import { ActionParamsProps } from '../../../../types'; import { SlackActionParams } from '../types'; import { TextAreaWithMessageVariables } from '../../text_area_with_message_variables'; -import { recoveredActionGroupMessage } from '../../../constants'; const SlackParamsFields: React.FunctionComponent> = ({ actionParams, @@ -19,17 +18,19 @@ const SlackParamsFields: React.FunctionComponent { const { message } = actionParams; + const [[isUsingDefault, defaultMessageUsed], setDefaultMessageUsage] = useState< + [boolean, string | undefined] + >([false, defaultMessage]); useEffect(() => { - if (defaultMessage === recoveredActionGroupMessage) { - editAction('message', defaultMessage, index); - } else if ( - (!message || message === recoveredActionGroupMessage) && - defaultMessage && - defaultMessage.length > 0 + if ( + !actionParams?.message || + (isUsingDefault && + actionParams?.message === defaultMessageUsed && + defaultMessageUsed !== defaultMessage) ) { + setDefaultMessageUsage([true, defaultMessage]); editAction('message', defaultMessage, index); } - // eslint-disable-next-line react-hooks/exhaustive-deps }, [defaultMessage]); diff --git a/x-pack/plugins/triggers_actions_ui/public/types.ts b/x-pack/plugins/triggers_actions_ui/public/types.ts index be8b7b9757e9e..a4eac1ab1da21 100644 --- a/x-pack/plugins/triggers_actions_ui/public/types.ts +++ b/x-pack/plugins/triggers_actions_ui/public/types.ts @@ -48,7 +48,7 @@ export interface ActionConnectorFieldsProps { } export interface ActionParamsProps { - actionParams: TParams; + actionParams: Partial; index: number; editAction: (key: string, value: AlertActionParam, index: number) => void; errors: IErrorObject; diff --git a/x-pack/plugins/uptime/common/runtime_types/monitor/state.ts b/x-pack/plugins/uptime/common/runtime_types/monitor/state.ts index d32c47bb5d3f9..46290b9e53b8e 100644 --- a/x-pack/plugins/uptime/common/runtime_types/monitor/state.ts +++ b/x-pack/plugins/uptime/common/runtime_types/monitor/state.ts @@ -23,9 +23,14 @@ export const StateType = t.intersection([ up: t.number, down: t.number, }), - monitor: t.partial({ - name: t.string, - }), + monitor: t.intersection([ + t.partial({ + name: t.string, + }), + t.type({ + type: t.string, + }), + ]), }), t.partial({ tls: t.partial({ diff --git a/x-pack/plugins/uptime/public/apps/uptime_app.tsx b/x-pack/plugins/uptime/public/apps/uptime_app.tsx index c928ac0dc458f..9535cfdb8c8b0 100644 --- a/x-pack/plugins/uptime/public/apps/uptime_app.tsx +++ b/x-pack/plugins/uptime/public/apps/uptime_app.tsx @@ -32,9 +32,11 @@ import { import { store } from '../state'; import { kibanaService } from '../state/kibana_service'; import { ScopedHistory } from '../../../../../src/core/public'; +import { EuiThemeProvider } from '../../../observability/public'; export interface UptimeAppColors { danger: string; + dangerBehindText: string; success: string; gray: string; range: string; @@ -103,24 +105,26 @@ const Application = (props: UptimeAppProps) => { services={{ ...core, ...plugins, triggersActionsUi: startPlugins.triggersActionsUi }} > - - - - - - - -
- - -
- - - - - - - + + + + + + + + +
+ + +
+ + + + + + + + diff --git a/x-pack/plugins/uptime/public/components/monitor/status_details/status_bar/ssl_certificate.tsx b/x-pack/plugins/uptime/public/components/monitor/status_details/status_bar/ssl_certificate.tsx index ffe4f5d759e03..4c0824b5dfa4f 100644 --- a/x-pack/plugins/uptime/public/components/monitor/status_details/status_bar/ssl_certificate.tsx +++ b/x-pack/plugins/uptime/public/components/monitor/status_details/status_bar/ssl_certificate.tsx @@ -11,7 +11,7 @@ import { FormattedMessage } from '@kbn/i18n/react'; import { Tls, X509Expiry } from '../../../../../common/runtime_types'; import { CERTIFICATES_ROUTE } from '../../../../../common/constants'; import { MonListDescription, MonListTitle } from './status_bar'; -import { CertStatusColumn } from '../../../overview/monitor_list/cert_status_column'; +import { CertStatusColumn } from '../../../overview/monitor_list/columns/cert_status_column'; interface Props { /** diff --git a/x-pack/plugins/uptime/public/components/overview/filter_group/filter_popover.tsx b/x-pack/plugins/uptime/public/components/overview/filter_group/filter_popover.tsx index da66e4179e1ac..e79c036d54e0e 100644 --- a/x-pack/plugins/uptime/public/components/overview/filter_group/filter_popover.tsx +++ b/x-pack/plugins/uptime/public/components/overview/filter_group/filter_popover.tsx @@ -54,6 +54,7 @@ export const FilterPopover = ({ const mItems = selectedItems.concat(allItems ?? []); const newItems = mItems.filter((item, index) => mItems.indexOf(item) === index); setItems(newItems); + setTempSelectedItems(selectedItems); }, [allItems, selectedItems]); useEffect(() => { @@ -73,7 +74,7 @@ export const FilterPopover = ({ isDisabled={disabled && selectedItems.length === 0} isSelected={tempSelectedItems.length > 0} numFilters={items.length} - numActiveFilters={tempSelectedItems.length} + numActiveFilters={isOpen ? tempSelectedItems.length : selectedItems.length} onClick={() => { setIsOpen(!isOpen); onFilterFieldChange(fieldName, tempSelectedItems); diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/__tests__/__snapshots__/monitor_list.test.tsx.snap b/x-pack/plugins/uptime/public/components/overview/monitor_list/__tests__/__snapshots__/monitor_list.test.tsx.snap index 1f5e86dc67386..edd901253f509 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/__tests__/__snapshots__/monitor_list.test.tsx.snap +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/__tests__/__snapshots__/monitor_list.test.tsx.snap @@ -199,7 +199,9 @@ exports[`MonitorList component MonitorListPagination component renders the pagin Object { "monitor_id": "foo", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 2, "up": 1, @@ -255,7 +257,9 @@ exports[`MonitorList component MonitorListPagination component renders the pagin Object { "monitor_id": "bar", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 0, "up": 2, @@ -507,7 +511,9 @@ exports[`MonitorList component renders error list 1`] = ` Object { "monitor_id": "foo", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 2, "up": 1, @@ -563,7 +569,9 @@ exports[`MonitorList component renders error list 1`] = ` Object { "monitor_id": "bar", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 0, "up": 2, @@ -710,7 +718,9 @@ exports[`MonitorList component renders loading state 1`] = ` Object { "monitor_id": "foo", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 2, "up": 1, @@ -766,7 +776,9 @@ exports[`MonitorList component renders loading state 1`] = ` Object { "monitor_id": "bar", "state": Object { - "monitor": Object {}, + "monitor": Object { + "type": "http", + }, "summary": Object { "down": 0, "up": 2, @@ -820,10 +832,10 @@ exports[`MonitorList component renders loading state 1`] = ` exports[`MonitorList component renders the monitor list 1`] = ` .c3 { - padding-left: 17px; + padding-right: 4px; } -.c5 { +.c4 { padding-top: 12px; } @@ -837,12 +849,6 @@ exports[`MonitorList component renders the monitor list 1`] = ` position: relative; } -.c4 { - white-space: nowrap; - overflow: hidden; - text-overflow: ellipsis; -} - @media (max-width:574px) { .c2 { min-width: 230px; @@ -966,7 +972,7 @@ exports[`MonitorList component renders the monitor list 1`] = `

@@ -1012,6 +1018,7 @@ exports[`MonitorList component renders the monitor list 1`] = ` data-test-subj="tableHeaderCell_state.url.full_2" role="columnheader" scope="col" + style="width:40%" >
-
+
+ + + +
+
+
+
+
- + in 0/1 location,
-
-
+ -
-
- 5m ago -
+ Checked Sept 4, 2020 9:31:38 AM
- +
-
-
- in 0/1 Location -
-
@@ -1172,21 +1176,46 @@ exports[`MonitorList component renders the monitor list 1`] = `
- + + Unnamed - foo + + +
+ +
+
@@ -1395,21 +1415,46 @@ exports[`MonitorList component renders the monitor list 1`] = `
- + + Unnamed - bar + + +
+ +
+
+ />
-
+
+ + + +
+
+
+
+
- + in 0/1 location,
-
-
+ -
-
- 5m ago -
+ Checked Sept 4, 2020 9:31:38 AM
- +
-
-
- in 0/1 Location -
-
+ />
, -] + + Get https://expired.badssl.com: x509: certificate has expired or is not yet valid + + + + `; exports[`MostRecentError component validates props with shallow render 1`] = ` diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/integration_group.test.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/integration_group.test.tsx index 3e7860e4e6ab4..62e34354dd356 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/integration_group.test.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/integration_group.test.tsx @@ -17,7 +17,7 @@ describe('IntegrationGroup', () => { monitor_id: '12345', state: { summary: {}, - monitor: {}, + monitor: { type: 'http' }, summaryPings: [], timestamp: '123', url: {}, @@ -48,7 +48,7 @@ describe('IntegrationGroup', () => { state: { timestamp: 'foo', summaryPings: [], - monitor: {}, + monitor: { type: 'http' }, summary: { up: 0, down: 0, diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/monitor_list_drawer.test.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/monitor_list_drawer.test.tsx index 4e8ffc64cfe92..6da19b2ccc4d2 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/monitor_list_drawer.test.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/__tests__/monitor_list_drawer.test.tsx @@ -17,7 +17,7 @@ describe('MonitorListDrawer component', () => { summary = { monitor_id: 'foo', state: { - monitor: {}, + monitor: { type: 'http' }, summaryPings: [ makePing({ docId: 'foo', diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/actions_popover/actions_popover.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/actions_popover/actions_popover.tsx index 9e96f0ca76535..3e1276b26b727 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/actions_popover/actions_popover.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/actions_popover/actions_popover.tsx @@ -46,7 +46,12 @@ export const ActionsPopoverComponent = ({ iconType="arrowDown" iconSide="right" > - Integrations + {i18n.translate( + 'xpack.uptime.monitorList.observabilityInvestigateColumn.popoverIconButton.label', + { + defaultMessage: 'Investigate', + } + )} } closePopover={() => togglePopoverIsVisible({ id: popoverId, open: false })} diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/enabled_alerts.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/enabled_alerts.tsx index d869c6d78ec11..b39162b70eda4 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/enabled_alerts.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/enabled_alerts.tsx @@ -5,9 +5,17 @@ */ import React, { useContext } from 'react'; -import { EuiCallOut, EuiListGroup, EuiLoadingSpinner, EuiSpacer, EuiText } from '@elastic/eui'; +import { + EuiCallOut, + EuiDescriptionList, + EuiDescriptionListDescription, + EuiDescriptionListTitle, + EuiListGroup, + EuiLoadingSpinner, +} from '@elastic/eui'; import { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group/list_group_item'; import { i18n } from '@kbn/i18n'; +import styled from 'styled-components'; import { UptimeSettingsContext } from '../../../../contexts'; import { Alert } from '../../../../../../triggers_actions_ui/public'; @@ -16,6 +24,15 @@ interface Props { loading: boolean; } +const LinkGroupList = styled(EuiListGroup)` + &&& { + a { + padding-left: 0; + padding-top: 0; + } + } +`; + export const EnabledAlerts = ({ monitorAlerts, loading }: Props) => { const { basePath } = useContext(UptimeSettingsContext); @@ -31,27 +48,24 @@ export const EnabledAlerts = ({ monitorAlerts, loading }: Props) => { }); return ( - <> - - - -

- {i18n.translate('xpack.uptime.monitorList.enabledAlerts.title', { - defaultMessage: 'Enabled alerts:', - description: 'Alerts enabled for this monitor', + + + {i18n.translate('xpack.uptime.monitorList.enabledAlerts.title', { + defaultMessage: 'Enabled alerts', + description: 'Alerts enabled for this monitor', + })} + + + {listItems.length === 0 && !loading && ( + - - - {listItems.length === 0 && !loading && ( - - )} - {loading ? : } - + /> + )} + {loading ? : } + + ); }; diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_list_drawer.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_list_drawer.tsx index 4b359099bc58c..ca7a608986e85 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_list_drawer.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_list_drawer.tsx @@ -6,13 +6,15 @@ import React from 'react'; import styled from 'styled-components'; -import { EuiLink, EuiFlexGroup, EuiFlexItem, EuiIcon, EuiText } from '@elastic/eui'; +import { EuiFlexGroup, EuiFlexItem, EuiSpacer } from '@elastic/eui'; +import { Alert } from '../../../../../../triggers_actions_ui/public'; import { MostRecentError } from './most_recent_error'; import { MonitorStatusList } from './monitor_status_list'; import { MonitorDetails, MonitorSummary } from '../../../../../common/runtime_types'; import { ActionsPopover } from './actions_popover/actions_popover_container'; import { EnabledAlerts } from './enabled_alerts'; -import { Alert } from '../../../../../../triggers_actions_ui/public'; +import { MonitorUrl } from './monitor_url'; +import { MostRecentRun } from './most_recent_run'; const ContainerDiv = styled.div` padding: 10px; @@ -47,19 +49,25 @@ export function MonitorListDrawerComponent({ - - - {monitorUrl} - - - + + + + + + + {/* TODO: add link to details page */} + + + + + {monitorDetails && monitorDetails.error && ( { return ( <> - - + + + + + + + + {(downChecks.has(UNNAMED_LOCATION) || upChecks.has(UNNAMED_LOCATION)) && ( <> diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_status_row.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_status_row.tsx index d0cc71ece989a..5bcb4ef97c3a4 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_status_row.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_status_row.tsx @@ -4,11 +4,10 @@ * you may not use this file except in compliance with the Elastic License. */ -import React, { useContext } from 'react'; -import { EuiHealth, EuiSpacer } from '@elastic/eui'; -import { FormattedMessage } from '@kbn/i18n/react'; -import { UptimeThemeContext } from '../../../../contexts'; +import React from 'react'; +import { EuiBadge, EuiSpacer } from '@elastic/eui'; import { UNNAMED_LOCATION, STATUS } from '../../../../../common/constants'; +import { getHealthMessage } from '../columns/monitor_status_column'; interface MonitorStatusRowProps { /** @@ -22,11 +21,7 @@ interface MonitorStatusRowProps { } export const MonitorStatusRow = ({ locationNames, status }: MonitorStatusRowProps) => { - const { - colors: { success, danger }, - } = useContext(UptimeThemeContext); - - const color = status === STATUS.UP ? success : danger; + const color = status === STATUS.UP ? 'secondary' : 'danger'; let checkListArray = [...locationNames]; // If un-named location exists, move it to end @@ -35,29 +30,13 @@ export const MonitorStatusRow = ({ locationNames, status }: MonitorStatusRowProp checkListArray.push(UNNAMED_LOCATION); } - if (locationNames.size === 0) { - return null; - } - const locations = checkListArray.join(', '); return ( - <> - - {status === STATUS.UP ? ( - - ) : ( - - )} - + + {getHealthMessage(status)} + + {locations || '--'} - + ); }; diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_url.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_url.tsx new file mode 100644 index 0000000000000..d988f5a582495 --- /dev/null +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/monitor_url.tsx @@ -0,0 +1,34 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +import React from 'react'; +import { i18n } from '@kbn/i18n'; +import { + EuiLink, + EuiDescriptionList, + EuiDescriptionListDescription, + EuiDescriptionListTitle, +} from '@elastic/eui'; + +interface Props { + monitorUrl: string; +} +export const MonitorUrl = ({ monitorUrl }: Props) => { + return ( + + + {i18n.translate('xpack.uptime.monitorList.drawer.url', { + defaultMessage: 'Url', + })} + + + + {monitorUrl} + + + + ); +}; diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_error.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_error.tsx index e7d9885680340..d611278d91033 100644 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_error.tsx +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_error.tsx @@ -4,7 +4,11 @@ * you may not use this file except in compliance with the Elastic License. */ import React from 'react'; -import { EuiText, EuiSpacer } from '@elastic/eui'; +import { + EuiDescriptionList, + EuiDescriptionListTitle, + EuiDescriptionListDescription, +} from '@elastic/eui'; import moment from 'moment'; import { i18n } from '@kbn/i18n'; import { MonitorPageLink } from '../../../common/monitor_page_link'; @@ -37,21 +41,19 @@ export const MostRecentError = ({ error, monitorId, timestamp }: MostRecentError const timestampStr = timestamp ? moment(new Date(timestamp).valueOf()).fromNow() : ''; return ( - <> - - -

- {i18n.translate('xpack.uptime.monitorList.mostRecentError.title', { - defaultMessage: 'Most recent error ({timestamp})', - values: { timestamp: timestampStr }, - description: 'Most Recent Error title in Monitor List Expanded row', - })} -

- - - - {error?.message} - - + + + {i18n.translate('xpack.uptime.monitorList.mostRecentError.title', { + defaultMessage: 'Most recent error ({timestamp})', + values: { timestamp: timestampStr }, + description: 'Most Recent Error title in Monitor List Expanded row', + })} + + + + {error?.message} + + + ); }; diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_run.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_run.tsx new file mode 100644 index 0000000000000..cd9108a36f332 --- /dev/null +++ b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_drawer/most_recent_run.tsx @@ -0,0 +1,34 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ +import React from 'react'; +import { + EuiDescriptionList, + EuiDescriptionListTitle, + EuiDescriptionListDescription, + EuiText, +} from '@elastic/eui'; +import moment from 'moment'; +import { i18n } from '@kbn/i18n'; +import { MonitorSummary } from '../../../../../common/runtime_types'; + +interface Props { + summary: MonitorSummary; +} + +export const MostRecentRun = ({ summary }: Props) => { + return ( + + + {i18n.translate('xpack.uptime.monitorList.drawer.mostRecentRun', { + defaultMessage: 'Most recent test run', + })} + + + {moment(summary.state.timestamp).format('LLL').toString()} + + + ); +}; diff --git a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_status_column.tsx b/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_status_column.tsx deleted file mode 100644 index 7140211d18807..0000000000000 --- a/x-pack/plugins/uptime/public/components/overview/monitor_list/monitor_list_status_column.tsx +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ - -import React from 'react'; -import moment from 'moment'; -import { i18n } from '@kbn/i18n'; -import styled from 'styled-components'; -import { EuiHealth, EuiFlexGroup, EuiFlexItem, EuiText, EuiToolTip } from '@elastic/eui'; -import { parseTimestamp } from './parse_timestamp'; -import { Ping } from '../../../../common/runtime_types'; -import { - STATUS, - SHORT_TIMESPAN_LOCALE, - UNNAMED_LOCATION, - SHORT_TS_LOCALE, -} from '../../../../common/constants'; - -import * as labels from './translations'; - -interface MonitorListStatusColumnProps { - status: string; - timestamp: string; - summaryPings: Ping[]; -} - -const PaddedSpan = styled.span` - padding-left: 17px; -`; - -const StatusColumnFlexG = styled(EuiFlexGroup)` - @media (max-width: 574px) { - min-width: 230px; - } -`; - -const getHealthColor = (status: string): string => { - switch (status) { - case STATUS.UP: - return 'success'; - case STATUS.DOWN: - return 'danger'; - default: - return ''; - } -}; - -const getHealthMessage = (status: string): string | null => { - switch (status) { - case STATUS.UP: - return labels.UP; - case STATUS.DOWN: - return labels.DOWN; - default: - return null; - } -}; - -const getRelativeShortTimeStamp = (timeStamp: any) => { - const prevLocale: string = moment.locale() ?? 'en'; - - const shortLocale = moment.locale(SHORT_TS_LOCALE) === SHORT_TS_LOCALE; - - if (!shortLocale) { - moment.defineLocale(SHORT_TS_LOCALE, SHORT_TIMESPAN_LOCALE); - } - - const shortTimestamp = parseTimestamp(timeStamp).fromNow(); - - // Reset it so, it does't impact other part of the app - moment.locale(prevLocale); - return shortTimestamp; -}; - -export const getLocationStatus = (summaryPings: Ping[], status: string) => { - const upPings: Set = new Set(); - const downPings: Set = new Set(); - - summaryPings.forEach((summaryPing: Ping) => { - const location = summaryPing?.observer?.geo?.name ?? UNNAMED_LOCATION; - - if (summaryPing.monitor.status === STATUS.UP) { - upPings.add(location); - } else if (summaryPing.monitor.status === STATUS.DOWN) { - downPings.add(location); - } - }); - - // if monitor is down in one dns, it will be considered down so removing it from up list - const absUpChecks: Set = new Set([...upPings].filter((item) => !downPings.has(item))); - - const totalLocations = absUpChecks.size + downPings.size; - let statusMessage = ''; - if (status === STATUS.DOWN) { - statusMessage = `${downPings.size}/${totalLocations}`; - } else { - statusMessage = `${absUpChecks.size}/${totalLocations}`; - } - - if (totalLocations > 1) { - return i18n.translate('xpack.uptime.monitorList.statusColumn.locStatusMessage.multiple', { - defaultMessage: 'in {noLoc} Locations', - values: { noLoc: statusMessage }, - }); - } - - return i18n.translate('xpack.uptime.monitorList.statusColumn.locStatusMessage', { - defaultMessage: 'in {noLoc} Location', - values: { noLoc: statusMessage }, - }); -}; - -export const MonitorListStatusColumn = ({ - status, - summaryPings = [], - timestamp: tsString, -}: MonitorListStatusColumnProps) => { - const timestamp = parseTimestamp(tsString); - return ( - - - - {getHealthMessage(status)} - - - - {timestamp.toLocaleString()} - - } - > - - {getRelativeShortTimeStamp(tsString)} - - - - - - {getLocationStatus(summaryPings, status)} - - - ); -}; diff --git a/x-pack/plugins/uptime/public/contexts/uptime_theme_context.tsx b/x-pack/plugins/uptime/public/contexts/uptime_theme_context.tsx index f0a702b9c0b75..a2f50c44f8ca4 100644 --- a/x-pack/plugins/uptime/public/contexts/uptime_theme_context.tsx +++ b/x-pack/plugins/uptime/public/contexts/uptime_theme_context.tsx @@ -26,6 +26,7 @@ export interface UptimeThemeContextValues { const defaultContext: UptimeThemeContextValues = { colors: { danger: euiLightVars.euiColorDanger, + dangerBehindText: euiDarkVars.euiColorVis9_behindText, mean: euiLightVars.euiColorPrimary, range: euiLightVars.euiFocusBackgroundColor, success: euiLightVars.euiColorSuccess, @@ -49,7 +50,8 @@ export const UptimeThemeContextProvider: React.FC = ({ darkMo let colors: UptimeAppColors; if (darkMode) { colors = { - danger: euiDarkVars.euiColorDanger, + danger: euiDarkVars.euiColorVis9, + dangerBehindText: euiDarkVars.euiColorVis9_behindText, mean: euiDarkVars.euiColorPrimary, gray: euiDarkVars.euiColorLightShade, range: euiDarkVars.euiFocusBackgroundColor, @@ -59,7 +61,8 @@ export const UptimeThemeContextProvider: React.FC = ({ darkMo }; } else { colors = { - danger: euiLightVars.euiColorDanger, + danger: euiLightVars.euiColorVis9, + dangerBehindText: euiLightVars.euiColorVis9_behindText, mean: euiLightVars.euiColorPrimary, gray: euiLightVars.euiColorLightShade, range: euiLightVars.euiFocusBackgroundColor, diff --git a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_apm_href.test.ts b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_apm_href.test.ts index 2444cfbee63d5..bbd389195d9dc 100644 --- a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_apm_href.test.ts +++ b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_apm_href.test.ts @@ -14,7 +14,7 @@ describe('getApmHref', () => { monitor_id: 'foo', state: { summary: {}, - monitor: {}, + monitor: { type: 'http' }, summaryPings: [ makePing({ docId: 'foo', diff --git a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_infra_href.test.ts b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_infra_href.test.ts index b1247ad5b8935..44e29c81f43f8 100644 --- a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_infra_href.test.ts +++ b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_infra_href.test.ts @@ -30,7 +30,7 @@ describe('getInfraHref', () => { summaryPings: [ping], summary: {}, url: {}, - monitor: {}, + monitor: { type: 'http' }, timestamp: '123', }, }; diff --git a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_logging_href.test.ts b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_logging_href.test.ts index d2a7a96a8b6f9..ae94e6cadd541 100644 --- a/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_logging_href.test.ts +++ b/x-pack/plugins/uptime/public/lib/helper/observability_integration/__tests__/get_logging_href.test.ts @@ -38,7 +38,7 @@ describe('getLoggingHref', () => { summary: {}, summaryPings: [ping], timestamp: '123', - monitor: {}, + monitor: { type: 'http' }, url: {}, }, }; diff --git a/x-pack/plugins/uptime/public/lib/helper/test_helpers.ts b/x-pack/plugins/uptime/public/lib/helper/test_helpers.ts new file mode 100644 index 0000000000000..d18f2aa2a4e78 --- /dev/null +++ b/x-pack/plugins/uptime/public/lib/helper/test_helpers.ts @@ -0,0 +1,22 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +/* global jest */ + +import moment from 'moment'; +import { Moment } from 'moment-timezone'; + +export function mockMoment() { + // avoid timezone issues + jest.spyOn(moment.prototype, 'format').mockImplementation(function (this: Moment) { + return `Sept 4, 2020 9:31:38 AM`; + }); + + // convert relative time to absolute time to avoid timing issues + jest.spyOn(moment.prototype, 'fromNow').mockImplementation(function (this: Moment) { + return `15 minutes ago`; + }); +} diff --git a/x-pack/plugins/uptime/public/pages/overview.tsx b/x-pack/plugins/uptime/public/pages/overview.tsx index 9594819e385c0..e2b8e911b5a88 100644 --- a/x-pack/plugins/uptime/public/pages/overview.tsx +++ b/x-pack/plugins/uptime/public/pages/overview.tsx @@ -10,7 +10,6 @@ import styled from 'styled-components'; import { i18n } from '@kbn/i18n'; import { useDispatch } from 'react-redux'; import { useGetUrlParams } from '../hooks'; -import { stringifyUrlParams } from '../lib/helper/stringify_url_params'; import { PageHeader } from './page_header'; import { IIndexPattern } from '../../../../../src/plugins/data/public'; import { useUpdateKueryString } from '../hooks'; @@ -63,8 +62,6 @@ export const OverviewPageComponent = React.memo( dispatch(getMonitorAlertsAction.get()); }, [dispatch]); - const linkParameters = stringifyUrlParams(params, true); - const heading = i18n.translate('xpack.uptime.overviewPage.headerText', { defaultMessage: 'Overview', description: `The text that will be displayed in the app's heading when the Overview page loads.`, @@ -93,7 +90,7 @@ export const OverviewPageComponent = React.memo( - + ); diff --git a/x-pack/plugins/uptime/server/lib/requests/search/__tests__/monitor_summary_iterator.test.ts b/x-pack/plugins/uptime/server/lib/requests/search/__tests__/monitor_summary_iterator.test.ts index 8ba5be943304c..6705bcac3c0ff 100644 --- a/x-pack/plugins/uptime/server/lib/requests/search/__tests__/monitor_summary_iterator.test.ts +++ b/x-pack/plugins/uptime/server/lib/requests/search/__tests__/monitor_summary_iterator.test.ts @@ -98,7 +98,7 @@ const makeMonitorSummaries = (count: number): MonitorSummary[] => { summaries.push({ monitor_id: id, state: { - monitor: {}, + monitor: { type: 'http' }, timestamp: (123 + i).toString(), url: {}, summaryPings: [], diff --git a/x-pack/plugins/uptime/server/lib/requests/search/refine_potential_matches.ts b/x-pack/plugins/uptime/server/lib/requests/search/refine_potential_matches.ts index dc3af2805d13f..bf0c7fce2be75 100644 --- a/x-pack/plugins/uptime/server/lib/requests/search/refine_potential_matches.ts +++ b/x-pack/plugins/uptime/server/lib/requests/search/refine_potential_matches.ts @@ -86,6 +86,7 @@ export const summaryPingsToSummary = (summaryPings: Ping[]): MonitorSummary => { timestamp: latest.timestamp, monitor: { name: latest.monitor?.name, + type: latest.monitor?.type, }, url: latest.url ?? {}, summary: { diff --git a/x-pack/test/api_integration/apis/uptime/rest/__snapshots__/monitor_states_real_data.snap b/x-pack/test/api_integration/apis/uptime/rest/__snapshots__/monitor_states_real_data.snap index 50625683b605d..93abfaf67a009 100644 --- a/x-pack/test/api_integration/apis/uptime/rest/__snapshots__/monitor_states_real_data.snap +++ b/x-pack/test/api_integration/apis/uptime/rest/__snapshots__/monitor_states_real_data.snap @@ -63,6 +63,7 @@ Object { "state": Object { "monitor": Object { "name": "", + "type": "http", }, "observer": Object { "geo": Object { @@ -242,6 +243,7 @@ Object { "state": Object { "monitor": Object { "name": "", + "type": "http", }, "observer": Object { "geo": Object { diff --git a/x-pack/test/apm_api_integration/basic/tests/index.ts b/x-pack/test/apm_api_integration/basic/tests/index.ts index e9bc59df96108..27e9528a658a9 100644 --- a/x-pack/test/apm_api_integration/basic/tests/index.ts +++ b/x-pack/test/apm_api_integration/basic/tests/index.ts @@ -16,9 +16,10 @@ export default function apmApiIntegrationTests({ loadTestFile }: FtrProviderCont }); describe('Services', function () { + loadTestFile(require.resolve('./services/agent_name')); loadTestFile(require.resolve('./services/annotations')); + loadTestFile(require.resolve('./services/throughput')); loadTestFile(require.resolve('./services/top_services')); - loadTestFile(require.resolve('./services/agent_name')); loadTestFile(require.resolve('./services/transaction_types')); }); diff --git a/x-pack/test/apm_api_integration/basic/tests/services/__snapshots__/throughput.snap b/x-pack/test/apm_api_integration/basic/tests/services/__snapshots__/throughput.snap new file mode 100644 index 0000000000000..434660cdc2c62 --- /dev/null +++ b/x-pack/test/apm_api_integration/basic/tests/services/__snapshots__/throughput.snap @@ -0,0 +1,250 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`Throughput when data is loaded returns the service throughput has the correct throughput 1`] = ` +Array [ + Object { + "x": 1601389800000, + "y": 6, + }, + Object { + "x": 1601389830000, + "y": 0, + }, + Object { + "x": 1601389860000, + "y": 0, + }, + Object { + "x": 1601389890000, + "y": 0, + }, + Object { + "x": 1601389920000, + "y": 3, + }, + Object { + "x": 1601389950000, + "y": 1, + }, + Object { + "x": 1601389980000, + "y": 0, + }, + Object { + "x": 1601390010000, + "y": 0, + }, + Object { + "x": 1601390040000, + "y": 3, + }, + Object { + "x": 1601390070000, + "y": 2, + }, + Object { + "x": 1601390100000, + "y": 0, + }, + Object { + "x": 1601390130000, + "y": 0, + }, + Object { + "x": 1601390160000, + "y": 7, + }, + Object { + "x": 1601390190000, + "y": 3, + }, + Object { + "x": 1601390220000, + "y": 2, + }, + Object { + "x": 1601390250000, + "y": 0, + }, + Object { + "x": 1601390280000, + "y": 0, + }, + Object { + "x": 1601390310000, + "y": 8, + }, + Object { + "x": 1601390340000, + "y": 0, + }, + Object { + "x": 1601390370000, + "y": 0, + }, + Object { + "x": 1601390400000, + "y": 3, + }, + Object { + "x": 1601390430000, + "y": 0, + }, + Object { + "x": 1601390460000, + "y": 0, + }, + Object { + "x": 1601390490000, + "y": 0, + }, + Object { + "x": 1601390520000, + "y": 4, + }, + Object { + "x": 1601390550000, + "y": 3, + }, + Object { + "x": 1601390580000, + "y": 2, + }, + Object { + "x": 1601390610000, + "y": 0, + }, + Object { + "x": 1601390640000, + "y": 1, + }, + Object { + "x": 1601390670000, + "y": 2, + }, + Object { + "x": 1601390700000, + "y": 0, + }, + Object { + "x": 1601390730000, + "y": 0, + }, + Object { + "x": 1601390760000, + "y": 4, + }, + Object { + "x": 1601390790000, + "y": 1, + }, + Object { + "x": 1601390820000, + "y": 1, + }, + Object { + "x": 1601390850000, + "y": 0, + }, + Object { + "x": 1601390880000, + "y": 6, + }, + Object { + "x": 1601390910000, + "y": 0, + }, + Object { + "x": 1601390940000, + "y": 3, + }, + Object { + "x": 1601390970000, + "y": 0, + }, + Object { + "x": 1601391000000, + "y": 4, + }, + Object { + "x": 1601391030000, + "y": 0, + }, + Object { + "x": 1601391060000, + "y": 1, + }, + Object { + "x": 1601391090000, + "y": 0, + }, + Object { + "x": 1601391120000, + "y": 2, + }, + Object { + "x": 1601391150000, + "y": 1, + }, + Object { + "x": 1601391180000, + "y": 2, + }, + Object { + "x": 1601391210000, + "y": 0, + }, + Object { + "x": 1601391240000, + "y": 1, + }, + Object { + "x": 1601391270000, + "y": 0, + }, + Object { + "x": 1601391300000, + "y": 1, + }, + Object { + "x": 1601391330000, + "y": 0, + }, + Object { + "x": 1601391360000, + "y": 1, + }, + Object { + "x": 1601391390000, + "y": 0, + }, + Object { + "x": 1601391420000, + "y": 0, + }, + Object { + "x": 1601391450000, + "y": 0, + }, + Object { + "x": 1601391480000, + "y": 10, + }, + Object { + "x": 1601391510000, + "y": 3, + }, + Object { + "x": 1601391540000, + "y": 1, + }, + Object { + "x": 1601391570000, + "y": 0, + }, + Object { + "x": 1601391600000, + "y": 0, + }, +] +`; diff --git a/x-pack/test/apm_api_integration/basic/tests/services/throughput.ts b/x-pack/test/apm_api_integration/basic/tests/services/throughput.ts new file mode 100644 index 0000000000000..aea4213f7e657 --- /dev/null +++ b/x-pack/test/apm_api_integration/basic/tests/services/throughput.ts @@ -0,0 +1,85 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ +import expect from '@kbn/expect'; +import qs from 'querystring'; +import { first, last } from 'lodash'; +import archives_metadata from '../../../common/archives_metadata'; +import { FtrProviderContext } from '../../../common/ftr_provider_context'; + +export default function ApiTest({ getService }: FtrProviderContext) { + const supertest = getService('supertest'); + const esArchiver = getService('esArchiver'); + + const archiveName = 'apm_8.0.0'; + const metadata = archives_metadata[archiveName]; + + describe('Throughput', () => { + describe('when data is not loaded', () => { + it('handles the empty state', async () => { + const response = await supertest.get( + `/api/apm/services/opbeans-java/throughput?${qs.stringify({ + start: metadata.start, + end: metadata.end, + uiFilters: encodeURIComponent('{}'), + transactionType: 'request', + })}` + ); + expect(response.status).to.be(200); + expect(response.body.throughput.length).to.be(0); + }); + }); + + describe('when data is loaded', () => { + before(() => esArchiver.load(archiveName)); + after(() => esArchiver.unload(archiveName)); + + describe('returns the service throughput', () => { + let throughputResponse: { + throughput: Array<{ x: number; y: number | null }>; + }; + before(async () => { + const response = await supertest.get( + `/api/apm/services/opbeans-java/throughput?${qs.stringify({ + start: metadata.start, + end: metadata.end, + uiFilters: encodeURIComponent('{}'), + transactionType: 'request', + })}` + ); + throughputResponse = response.body; + }); + + it('returns some data', () => { + expect(throughputResponse.throughput.length).to.be.greaterThan(0); + + const nonNullDataPoints = throughputResponse.throughput.filter(({ y }) => y !== null); + + expect(nonNullDataPoints.length).to.be.greaterThan(0); + }); + + it('has the correct start date', () => { + expectSnapshot( + new Date(first(throughputResponse.throughput)?.x ?? NaN).toISOString() + ).toMatchInline(`"2020-09-29T14:30:00.000Z"`); + }); + + it('has the correct end date', () => { + expectSnapshot( + new Date(last(throughputResponse.throughput)?.x ?? NaN).toISOString() + ).toMatchInline(`"2020-09-29T15:00:00.000Z"`); + }); + + it('has the correct number of buckets', () => { + expectSnapshot(throughputResponse.throughput.length).toMatchInline(`61`); + }); + + it('has the correct throughput', () => { + expectSnapshot(throughputResponse.throughput).toMatch(); + }); + }); + }); + }); +} diff --git a/x-pack/test/security_solution_endpoint_api_int/apis/resolver/children.ts b/x-pack/test/security_solution_endpoint_api_int/apis/resolver/children.ts index b56dea94ab569..c51b322478f34 100644 --- a/x-pack/test/security_solution_endpoint_api_int/apis/resolver/children.ts +++ b/x-pack/test/security_solution_endpoint_api_int/apis/resolver/children.ts @@ -53,6 +53,7 @@ export default function resolverAPIIntegrationTests({ getService }: FtrProviderC }); startEvent = generator.generateEvent({ + timestamp: (timestampSafeVersion(infoEvent) ?? 0) + 100, parentEntityID: entityIDSafeVersion(infoEvent), ancestry: createAncestryArray([infoEvent, origin]), eventType: ['start'], @@ -60,6 +61,7 @@ export default function resolverAPIIntegrationTests({ getService }: FtrProviderC }); execEvent = generator.generateEvent({ + timestamp: (timestampSafeVersion(startEvent) ?? 0) + 100, parentEntityID: entityIDSafeVersion(startEvent), ancestry: createAncestryArray([startEvent, infoEvent]), eventType: ['change'], @@ -107,6 +109,7 @@ export default function resolverAPIIntegrationTests({ getService }: FtrProviderC }); infoEvent = generator.generateEvent({ + timestamp: (timestampSafeVersion(startEvent) ?? 0) + 100, parentEntityID: entityIDSafeVersion(origin), ancestry: createAncestryArray([origin]), entityID: entityIDSafeVersion(startEvent), @@ -115,6 +118,7 @@ export default function resolverAPIIntegrationTests({ getService }: FtrProviderC }); execEvent = generator.generateEvent({ + timestamp: (timestampSafeVersion(infoEvent) ?? 0) + 100, parentEntityID: entityIDSafeVersion(origin), ancestry: createAncestryArray([origin]), eventType: ['change'],